fast-clean-architecture 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

fast_clean_architecture/generators/config_updater.py

@@ -1,20 +1,21 @@
-"""Configuration updater for managing fca-config.yaml updates."""
+"""Configuration updater for managing fca_config.yaml updates."""
 
 import shutil
 from pathlib import Path
-from typing import Optional, Dict, Any
+from typing import Any, Dict, List, Optional, Union
 
 from rich.console import Console
 
 from ..config import Config
+from ..exceptions import ConfigurationError, Result, SecurityError, ValidationError
 from ..utils import generate_timestamp
-from ..exceptions import ConfigurationError
+from ..validation import Validator
 
 
 class ConfigUpdater:
-    """Handles updates to the fca-config.yaml file with proper timestamp management."""
+    """Handles updates to the fca_config.yaml file with proper timestamp management."""
 
-    def __init__(self, config_path: Path, console: Console = None):
+    def __init__(self, config_path: Path, console: Optional[Console] = None):
         self.config_path = config_path
         self.console = console or Console()
         self._config: Optional[Config] = None
@@ -28,27 +29,95 @@ class ConfigUpdater:
 
     def _load_config(self) -> Config:
         """Load configuration from file or create default."""
-        if self.config_path.exists():
-            return Config.load_from_file(self.config_path)
-        else:
-            # Create default config if it doesn't exist
-            config = Config.create_default()
-            config.save_to_file(self.config_path)
-            return config
+        result = self._load_config_safe()
+        return result.unwrap()
+
+    def _load_config_safe(self) -> Result[Config, ConfigurationError]:
+        """Safely load configuration with Result pattern."""
+        try:
+            if self.config_path.exists():
+                config = Config.load_from_file(self.config_path)
+                return Result.success(config)
+            else:
+                # Create default config if it doesn't exist
+                config = Config.create_default()
+                config.save_to_file(self.config_path)
+                return Result.success(config)
+        except Exception as e:
+            return Result.failure(
+                ConfigurationError(
+                    f"Failed to load configuration from {self.config_path}",
+                    context={"path": str(self.config_path), "error": str(e)},
+                )
+            )
 
     def backup_config(self) -> Path:
         """Create a backup of the current configuration."""
-        if not self.config_path.exists():
-            raise ConfigurationError(
-                f"Configuration file does not exist: {self.config_path}"
+        result = self._backup_config_safe()
+        return result.unwrap()
+
+    def _backup_config_safe(self) -> Result[Path, ConfigurationError]:
+        """Safely create a backup with Result pattern."""
+        try:
+            if not self.config_path.exists():
+                return Result.failure(
+                    ConfigurationError(
+                        f"Configuration file does not exist: {self.config_path}",
+                        context={"path": str(self.config_path)},
+                    )
+                )
+
+            timestamp = generate_timestamp().replace(":", "-").replace(".", "-")
+            # Create backup directory if it doesn't exist
+            backup_dir = self.config_path.parent / "fca_config_backups"
+            backup_dir.mkdir(exist_ok=True)
+            backup_path = (
+                backup_dir / f"{self.config_path.stem}.backup.{timestamp}.yaml"
             )
 
-        timestamp = generate_timestamp().replace(":", "-").replace(".", "-")
-        backup_path = self.config_path.with_suffix(f".backup.{timestamp}.yaml")
+            shutil.copy2(self.config_path, backup_path)
+            self.console.print(f"📋 Config backed up to: {backup_path}")
+
+            # Clean up old backups (keep only last 5)
+            self._cleanup_old_backups()
 
-        shutil.copy2(self.config_path, backup_path)
-        self.console.print(f"📋 Config backed up to: {backup_path}")
-        return backup_path
+            return Result.success(backup_path)
+        except Exception as e:
+            return Result.failure(
+                ConfigurationError(
+                    f"Failed to create backup: {e}",
+                    context={"source": str(self.config_path), "error": str(e)},
+                )
+            )
+
+    def _cleanup_old_backups(self, keep_count: int = 5) -> None:
+        """Clean up old backup files created by ConfigUpdater, keeping only the most recent ones."""
+        try:
+            backup_dir = self.config_path.parent / "fca_config_backups"
+            if not backup_dir.exists():
+                return
+
+            # Pattern for ConfigUpdater backups: filename.backup.timestamp.yaml
+            backup_pattern = f"{self.config_path.stem}.backup.*.yaml"
+            backup_files = list(backup_dir.glob(backup_pattern))
+
+            if len(backup_files) > keep_count:
+                # Sort by modification time (newest first)
+                backup_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+                # Remove old backups
+                for old_backup in backup_files[keep_count:]:
+                    try:
+                        old_backup.unlink()
+                        self.console.print(
+                            f"🗑️  Removed old backup: {old_backup.name}", style="dim"
+                        )
+                    except OSError:
+                        # Ignore errors when cleaning up old backups
+                        pass
+        except OSError:
+            # Don't fail the main operation if backup cleanup fails
+            pass
 
     def add_system(
         self,
@@ -56,17 +125,33 @@ class ConfigUpdater:
         description: Optional[str] = None,
         backup: bool = True,
     ) -> None:
-        """Add a new system to the configuration."""
+        """Add a new system to the configuration with validation."""
+        # Validate system name
+        name_result = Validator.validate_system_name(system_name)
+        if name_result.is_failure:
+            name_result.unwrap()  # This will raise the error
+
+        # Validate description if provided
+        if description:
+            desc_result = Validator.validate_description(description)
+            if desc_result.is_failure:
+                desc_result.unwrap()  # This will raise the error
+
         if backup and self.config_path.exists():
             self.backup_config()
 
         # Add system to config
-        self.config.add_system(system_name, description)
+        validated_name = name_result.value
+        if validated_name is None:
+            raise ValidationError(
+                "Validated name should not be None after successful validation"
+            )
+        self.config.add_system(validated_name, description or "")
 
         # Save updated config
         self._save_config_atomically()
 
-        self.console.print(f"✅ Added system: {system_name}")
+        self.console.print(f"✅ Added system: {name_result.value}")
 
     def add_module(
         self,
@@ -75,17 +160,45 @@ class ConfigUpdater:
         description: Optional[str] = None,
         backup: bool = True,
     ) -> None:
-        """Add a new module to a system."""
+        """Add a new module to a system with validation."""
+        # Validate system name
+        system_result = Validator.validate_system_name(system_name)
+        if system_result.is_failure:
+            system_result.unwrap()  # This will raise the error
+
+        # Validate module name
+        module_result = Validator.validate_module_name(module_name)
+        if module_result.is_failure:
+            module_result.unwrap()  # This will raise the error
+
+        # Validate description if provided
+        if description:
+            desc_result = Validator.validate_description(description)
+            if desc_result.is_failure:
+                desc_result.unwrap()  # This will raise the error
+
         if backup and self.config_path.exists():
             self.backup_config()
 
         # Add module to config
-        self.config.add_module(system_name, module_name, description)
+        validated_system = system_result.value
+        validated_module = module_result.value
+        if validated_system is None:
+            raise ValidationError(
+                "Validated system should not be None after successful validation"
+            )
+        if validated_module is None:
+            raise ValidationError(
+                "Validated module should not be None after successful validation"
+            )
+        self.config.add_module(validated_system, validated_module, description or "")
 
         # Save updated config
         self._save_config_atomically()
 
-        self.console.print(f"✅ Added module: {module_name} to system: {system_name}")
+        self.console.print(
+            f"✅ Added module: {module_result.value} to system: {system_result.value}"
+        )
 
     def add_component(
         self,
@@ -97,18 +210,39 @@ class ConfigUpdater:
         file_path: Optional[Path] = None,
         backup: bool = True,
     ) -> None:
-        """Add a new component to a module."""
-        if backup and self.config_path.exists():
-            self.backup_config()
-
-        # Add component to config
-        self.config.add_component(
+        """Add a new component to a module with comprehensive validation."""
+        # Validate all inputs
+        validation_result = Validator.validate_component_creation(
             system_name=system_name,
             module_name=module_name,
             layer=layer,
             component_type=component_type,
             component_name=component_name,
-            file_path=str(file_path) if file_path else None,
+            file_path=file_path,
+        )
+
+        if validation_result.is_failure:
+            validation_result.unwrap()  # This will raise the error
+
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Add component to config using validated data
+        validated_data = validation_result.value
+        if validated_data is None:
+            raise ConfigurationError("Validation result is None")
+
+        self.config.add_component(
+            system_name=validated_data["system_name"],
+            module_name=validated_data["module_name"],
+            layer=validated_data["layer"],
+            component_type=validated_data["component_type"],
+            component_name=validated_data["component_name"],
+            file_path=(
+                str(validated_data["file_path"])
+                if "file_path" in validated_data and validated_data["file_path"]
+                else None
+            ),
         )
 
         # Save updated config
@@ -266,7 +400,7 @@ class ConfigUpdater:
 
     def get_config_summary(self) -> Dict[str, Any]:
         """Get a summary of the current configuration."""
-        summary = {
+        summary: Dict[str, Any] = {
             "project": {
                 "name": self.config.project.name,
                 "version": self.config.project.version,
@@ -288,6 +422,12 @@ class ConfigUpdater:
 
     def _save_config_atomically(self) -> None:
         """Save configuration atomically to prevent corruption."""
+        result = self._save_config_atomically_safe()
+        result.unwrap()
+
+    def _save_config_atomically_safe(self) -> Result[None, ConfigurationError]:
+        """Safely save configuration with Result pattern."""
+        temp_path: Optional[Path] = None
         try:
             # Write to temporary file first
             temp_path = self.config_path.with_suffix(".tmp")
@@ -295,13 +435,21 @@ class ConfigUpdater:
 
             # Atomic move
             temp_path.replace(self.config_path)
+            return Result.success(None)
 
         except Exception as e:
             # Clean up temp file if it exists
-            temp_path = self.config_path.with_suffix(".tmp")
-            if temp_path.exists():
-                temp_path.unlink()
-            raise ConfigurationError(f"Failed to save configuration: {e}")
+            if temp_path and temp_path.exists():
+                try:
+                    temp_path.unlink()
+                except OSError:
+                    pass  # Ignore cleanup errors
+            return Result.failure(
+                ConfigurationError(
+                    f"Failed to save configuration: {e}",
+                    context={"config_path": str(self.config_path), "error": str(e)},
+                )
+            )
 
     def reload_config(self) -> None:
         """Reload configuration from file."""

fast_clean_architecture/generators/generator_factory.py

@@ -0,0 +1,223 @@
+"""Factory pattern implementation for generators.
+
+This module provides a factory for creating different types of generators
+with proper dependency injection and type safety.
+"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, Generic, Optional, Protocol, Type, TypeVar, Union
+
+from rich.console import Console
+
+from ..config import Config
+from ..exceptions import ComponentError
+from ..protocols import (
+    ComponentGeneratorProtocol,
+    SecurePathHandler,
+    TemplateValidatorProtocol,
+)
+from .component_generator import ComponentGenerator
+from .config_updater import ConfigUpdater
+from .package_generator import PackageGenerator
+from .template_validator import SimpleTemplateValidator
+from .validation_config import ValidationConfig
+
+# Type variables for enhanced type safety
+T = TypeVar("T")
+GeneratorType = TypeVar("GeneratorType")
+
+
+class GeneratorProtocol(Protocol):
+    """Base protocol for all generators."""
+
+    pass
+
+
+# ComponentGeneratorProtocol is imported from protocols module
+
+
+class GeneratorFactoryProtocol(Protocol):
+    """Protocol for generator factories."""
+
+    def create_generator(self, generator_type: str, **kwargs: Any) -> GeneratorProtocol:
+        """Create a generator of the specified type.
+
+        Args:
+            generator_type: Type of generator to create
+            **kwargs: Additional arguments for generator creation
+
+        Returns:
+            Generator instance
+
+        Raises:
+            ValueError: If generator type is not supported
+        """
+        ...
+
+
+class DependencyContainer:
+    """Container for managing dependencies and their lifecycle."""
+
+    def __init__(self, config: Config, console: Optional[Console] = None):
+        self.config = config
+        self.console = console or Console()
+        self._template_validator: Optional[TemplateValidatorProtocol] = None
+        self._path_handler: Optional[SecurePathHandler[Union[str, Path]]] = None
+
+    @property
+    def template_validator(self) -> TemplateValidatorProtocol:
+        """Get or create template validator instance."""
+        if self._template_validator is None:
+            # Create template environment for validator
+            import jinja2
+            from jinja2.sandbox import SandboxedEnvironment
+
+            from ..templates import TEMPLATES_DIR
+
+            template_env = SandboxedEnvironment(
+                loader=jinja2.FileSystemLoader(TEMPLATES_DIR),
+                trim_blocks=True,
+                lstrip_blocks=True,
+            )
+
+            validation_config = ValidationConfig(
+                sandbox_mode=True,
+                max_template_size_bytes=64 * 1024,  # 64KB limit
+                render_timeout_seconds=10,
+                max_variable_nesting_depth=10,
+            )
+
+            self._template_validator = SimpleTemplateValidator(
+                template_env, validation_config
+            )
+        return self._template_validator
+
+    @property
+    def path_handler(self) -> SecurePathHandler[Union[str, Path]]:
+        """Get or create path handler instance."""
+        if self._path_handler is None:
+            self._path_handler = SecurePathHandler[Union[str, Path]](
+                max_path_length=4096,
+                allowed_extensions=[".py", ".j2", ".yaml", ".yml", ".json"],
+            )
+        return self._path_handler
+
+
+class GeneratorFactory(GeneratorFactoryProtocol):
+    """Factory for creating generators with dependency injection.
+
+    This factory implements the factory pattern and provides dependency
+    injection for all generator types, ensuring loose coupling and
+    better testability.
+    """
+
+    def __init__(self, dependency_container: DependencyContainer):
+        """Initialize factory with dependency container.
+
+        Args:
+            dependency_container: Container with all required dependencies
+        """
+        self.dependencies = dependency_container
+
+        # Registry of available generators
+        self._generators: Dict[str, Type[GeneratorProtocol]] = {
+            "component": ComponentGenerator,
+            "package": PackageGenerator,
+            "config": ConfigUpdater,
+        }
+
+    def create_generator(self, generator_type: str, **kwargs: Any) -> GeneratorProtocol:
+        """Create a generator of the specified type with dependency injection.
+
+        Args:
+            generator_type: Type of generator ('component', 'package', 'config')
+            **kwargs: Additional arguments for specific generator types
+
+        Returns:
+            Generator instance with injected dependencies
+
+        Raises:
+            ValueError: If generator type is not supported
+        """
+        if generator_type not in self._generators:
+            available_types = ", ".join(self._generators.keys())
+            raise ValueError(
+                f"Unsupported generator type: {generator_type}. "
+                f"Available types: {available_types}"
+            )
+
+        generator_class = self._generators[generator_type]
+
+        # Create generator with appropriate dependencies
+        if generator_type == "component":
+            return self._create_component_generator(**kwargs)
+        elif generator_type == "package":
+            return self._create_package_generator(**kwargs)
+        elif generator_type == "config":
+            return self._create_config_updater(**kwargs)
+        else:
+            # This should never happen due to the check above, but included for completeness
+            raise ValueError(f"Unknown generator type: {generator_type}")
+
+    def _create_component_generator(self, **kwargs: Any) -> ComponentGenerator:
+        """Create ComponentGenerator with injected dependencies."""
+        return ComponentGenerator(
+            config=self.dependencies.config,
+            template_validator=self.dependencies.template_validator,
+            path_handler=self.dependencies.path_handler,
+            console=self.dependencies.console,
+            **kwargs,
+        )
+
+    def _create_package_generator(self, **kwargs: Any) -> PackageGenerator:
+        """Create PackageGenerator with injected dependencies."""
+        return PackageGenerator(console=self.dependencies.console, **kwargs)
+
+    def _create_config_updater(
+        self, config_path: Optional[Path] = None, **kwargs: Any
+    ) -> ConfigUpdater:
+        """Create ConfigUpdater with injected dependencies."""
+        if config_path is None:
+            # Use default config path from dependencies
+            config_path = Path("fca_config.yaml")
+
+        return ConfigUpdater(
+            config_path=config_path, console=self.dependencies.console, **kwargs
+        )
+
+    def register_generator(
+        self, generator_type: str, generator_class: Type[GeneratorProtocol]
+    ) -> None:
+        """Register a new generator type.
+
+        Args:
+            generator_type: Name of the generator type
+            generator_class: Class implementing the generator
+        """
+        self._generators[generator_type] = generator_class
+
+    def get_available_types(self) -> list[str]:
+        """Get list of available generator types.
+
+        Returns:
+            List of available generator type names
+        """
+        return list(self._generators.keys())
+
+
+# Convenience function for creating a factory with default dependencies
+def create_generator_factory(
+    config: Config, console: Optional[Console] = None
+) -> GeneratorFactory:
+    """Create a generator factory with default dependencies.
+
+    Args:
+        config: Configuration object
+        console: Optional console for output
+
+    Returns:
+        Configured generator factory
+    """
+    dependency_container = DependencyContainer(config, console)
+    return GeneratorFactory(dependency_container)

fast_clean_architecture/generators/package_generator.py

@@ -1,14 +1,14 @@
 """Package generator for creating directory structures and __init__.py files."""
 
 from pathlib import Path
-from typing import List, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 import jinja2
 from rich.console import Console
 
+from ..exceptions import TemplateError
 from ..templates import TEMPLATES_DIR
 from ..utils import ensure_directory
-from ..exceptions import TemplateError
 
 
 class PackageGenerator:
@@ -20,6 +20,7 @@ class PackageGenerator:
             loader=jinja2.FileSystemLoader(TEMPLATES_DIR),
             trim_blocks=True,
             lstrip_blocks=True,
+            autoescape=True,
         )
 
     def create_system_structure(
@@ -85,7 +86,7 @@ class PackageGenerator:
         )
 
         # Create layer directories
-        layers = {
+        layers: Dict[str, Dict[str, List[Any]]] = {
             "domain": {
                 "entities": [],
                 "repositories": [],
@@ -100,7 +101,6 @@ class PackageGenerator:
                 "models": [],
                 "repositories": [],
                 "external": [],
-                "internal": [],
             },
             "presentation": {
                 "api": [],
@@ -134,9 +134,11 @@ class PackageGenerator:
                     components=[],
                 )
 
-        # Create module.py file
+        # Create module API file
         module_content = f'"""\nModule registration for {module_name}.\n"""\n\n# Module configuration and dependencies\n'
-        (module_path / "module.py").write_text(module_content, encoding="utf-8")
+        (module_path / f"{module_name}_module_api.py").write_text(
+            module_content, encoding="utf-8"
+        )
 
         self.console.print(f"✅ Created module structure: {module_path}")
 
@@ -160,7 +162,7 @@ class PackageGenerator:
 
         self.console.print(f"📝 Updated {init_path}")
 
-    def _create_init_file(self, file_path: Path, **template_vars) -> None:
+    def _create_init_file(self, file_path: Path, **template_vars: Any) -> None:
         """Create __init__.py file from template."""
         try:
             template = self.template_env.get_template("__init__.py.j2")