fast-clean-architecture 1.0.0__tar.gz → 1.1.0__tar.gz

{fast_clean_architecture-1.0.0 → fast_clean_architecture-1.1.0}/.gitignore

@@ -224,7 +224,7 @@ $RECYCLE.BIN/
 # Project-specific
 # Configuration backups
 *.backup.*
-fca-config.yaml.backup.*
+fca_config.yaml.backup.*
 
 # Generated systems directory (if not tracking)
 # systems/
@@ -410,7 +410,7 @@ override.toml
 # systems/
 
 # Configuration file backups (already covered above but being explicit)
-fca-config.yaml.backup*
+fca_config.yaml.backup*
 
 # Any local test configurations
 test-config.yaml
@@ -946,12 +946,12 @@ fastlane/readme.md
 # Temporary files created by R markdown
 *.utf8.md
 *.knit.md
+*_prompt.md
 
 # R Environment Variables
 .Renviron
 
 # pkgdown site
-docs/
 
 # translation temp files
 po/*~

fast_clean_architecture-1.1.0/.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: local
+    hooks:
+      - id: export-requirements
+        name: Export requirements.txt
+        entry: poetry export -f requirements.txt --output requirements.txt
+        language: system
+        files: pyproject.toml
+        pass_filenames: false
+        stages: [commit]
+      - id: export-dev-requirements
+        name: Export dev requirements.txt
+        entry: poetry export -f requirements.txt --output requirements-dev.txt --extras dev
+        language: system
+        files: pyproject.toml
+        pass_filenames: false
+        stages: [commit]

{fast_clean_architecture-1.0.0 → fast_clean_architecture-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-clean-architecture
-Version: 1.0.0
+Version: 1.1.0
 Summary: CLI tool for scaffolding clean architecture in FastAPI projects
 Project-URL: Homepage, https://github.com/alden-technologies/fast-clean-architecture
 Project-URL: Repository, https://github.com/alden-technologies/fast-clean-architecture
@@ -17,28 +17,22 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Requires-Dist: jinja2<4.0.0,>=3.1.0
 Requires-Dist: pathlib-mate<2.0.0,>=1.0.0
+Requires-Dist: portalocker<3.0.0,>=2.0.0
+Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyyaml<7.0.0,>=6.0
 Requires-Dist: rich<14.0.0,>=13.0.0
+Requires-Dist: structlog<24.0.0,>=23.0.0
 Requires-Dist: typer[all]<1.0.0,>=0.9.0
-Provides-Extra: dev
-Requires-Dist: bandit<2.0.0,>=1.7.0; extra == 'dev'
-Requires-Dist: black<24.0.0,>=23.0.0; extra == 'dev'
-Requires-Dist: isort<6.0.0,>=5.0.0; extra == 'dev'
-Requires-Dist: mypy<2.0.0,>=1.0.0; extra == 'dev'
-Requires-Dist: pytest-cov<5.0.0,>=4.0.0; extra == 'dev'
-Requires-Dist: pytest<8.0.0,>=7.0.0; extra == 'dev'
-Requires-Dist: safety<3.0.0,>=2.0.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Fast Clean Architecture
@@ -76,36 +70,52 @@ poetry add fast-clean-architecture
 
 ### From Source
 
-#### Using pip
+#### Using Poetry (Recommended)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-pip install -e .
+poetry install
 ```
 
-#### Using Poetry
+#### Using pip with requirements.txt
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-poetry install
+pip install -r requirements.txt
+```
+
+#### Using pip (editable install)
+```bash
+git clone https://github.com/alden-technologies/fast-clean-architecture.git
+cd fast-clean-architecture
+pip install -e .
 ```
 
 ### Development Installation
 
-#### Using pip
+#### Using Poetry (Recommended)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-pip install -e ".[dev]"
+poetry install --extras dev
 ```
 
-#### Using Poetry
+#### Using pip with dev requirements
+```bash
+git clone https://github.com/alden-technologies/fast-clean-architecture.git
+cd fast-clean-architecture
+pip install -r requirements-dev.txt
+```
+
+#### Using pip (editable install with dev dependencies)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-poetry install --with dev
+pip install -e ".[dev]"
 ```
 
+**Note**: This project uses Poetry for dependency management. The `requirements.txt` and `requirements-dev.txt` files are provided for convenience and compatibility with pip-based workflows.
+
 ## 🏗️ Architecture Overview
 
 Fast Clean Architecture follows the clean architecture pattern with these layers:
@@ -130,7 +140,7 @@ Fast Clean Architecture follows the clean architecture pattern with these layers
 │           └── 📁 presentation/     # API layer
 │               ├── 📁 api/          # FastAPI routers
 │               └── 📁 schemas/      # Pydantic schemas
-└── 📄 fca-config.yaml             # Project configuration
+└── 📄 fca_config.yaml             # Project configuration
 ```
 
 ## 📋 Prerequisites
@@ -323,7 +333,7 @@ fca-scaffold create-component --help
 
 ### Configuration File
 
-The `fca-config.yaml` file tracks your project structure:
+The `fca_config.yaml` file tracks your project structure:
 
 ```yaml
 project:

{fast_clean_architecture-1.0.0 → fast_clean_architecture-1.1.0}/README.md

@@ -33,36 +33,52 @@ poetry add fast-clean-architecture
 
 ### From Source
 
-#### Using pip
+#### Using Poetry (Recommended)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-pip install -e .
+poetry install
 ```
 
-#### Using Poetry
+#### Using pip with requirements.txt
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-poetry install
+pip install -r requirements.txt
+```
+
+#### Using pip (editable install)
+```bash
+git clone https://github.com/alden-technologies/fast-clean-architecture.git
+cd fast-clean-architecture
+pip install -e .
 ```
 
 ### Development Installation
 
-#### Using pip
+#### Using Poetry (Recommended)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-pip install -e ".[dev]"
+poetry install --extras dev
 ```
 
-#### Using Poetry
+#### Using pip with dev requirements
+```bash
+git clone https://github.com/alden-technologies/fast-clean-architecture.git
+cd fast-clean-architecture
+pip install -r requirements-dev.txt
+```
+
+#### Using pip (editable install with dev dependencies)
 ```bash
 git clone https://github.com/alden-technologies/fast-clean-architecture.git
 cd fast-clean-architecture
-poetry install --with dev
+pip install -e ".[dev]"
 ```
 
+**Note**: This project uses Poetry for dependency management. The `requirements.txt` and `requirements-dev.txt` files are provided for convenience and compatibility with pip-based workflows.
+
 ## 🏗️ Architecture Overview
 
 Fast Clean Architecture follows the clean architecture pattern with these layers:
@@ -87,7 +103,7 @@ Fast Clean Architecture follows the clean architecture pattern with these layers
 │           └── 📁 presentation/     # API layer
 │               ├── 📁 api/          # FastAPI routers
 │               └── 📁 schemas/      # Pydantic schemas
-└── 📄 fca-config.yaml             # Project configuration
+└── 📄 fca_config.yaml             # Project configuration
 ```
 
 ## 📋 Prerequisites
@@ -280,7 +296,7 @@ fca-scaffold create-component --help
 
 ### Configuration File
 
-The `fca-config.yaml` file tracks your project structure:
+The `fca_config.yaml` file tracks your project structure:
 
 ```yaml
 project:

{fast_clean_architecture-1.0.0 → fast_clean_architecture-1.1.0/docs}/CHANGELOG.md

@@ -35,6 +35,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added dependency vulnerability scanning
 - Implemented secure file operations
 - Enhanced input validation and sanitization
+- **CRITICAL**: Fixed 3 security vulnerabilities in dependencies:
+  - Updated black to ^24.3.0 to fix CVE-2024-21503 (ReDoS vulnerability)
+  - Added pip ^25.0 constraint to fix PVE-2025-75180 (malicious wheel execution)
+  - Added setuptools ^78.1.1 constraint to fix CVE-2025-47273 (path traversal)
+- Resolved all Bandit security warnings with proper fixes and suppressions
+- Replaced MD5 hashing with SHA256 for error ID generation
+- Enabled Jinja2 autoescape to prevent XSS vulnerabilities
+- Replaced assert statements with proper exception handling
 
 ## [0.1.0] - 2024-01-15
 

{fast_clean_architecture-1.0.0 → fast_clean_architecture-1.1.0/docs}/CONTRIBUTING.md

@@ -102,6 +102,68 @@ Pull requests are the best way to propose changes to the codebase. We actively w
    poetry run mypy fast_clean_architecture
    ```
 
+## Dependency Management
+
+This project uses **Poetry** as the primary dependency manager, but also provides `requirements.txt` files for pip-based workflows.
+
+### Understanding the Files
+
+- **`pyproject.toml`**: Primary dependency definition (Poetry format)
+- **`poetry.lock`**: Locked dependency versions (Poetry)
+- **`requirements.txt`**: Production dependencies (pip format)
+- **`requirements-dev.txt`**: Development dependencies (pip format)
+
+### Updating Dependencies
+
+#### Adding New Dependencies
+
+**Using Poetry (Recommended)**
+```bash
+# Add production dependency
+poetry add package-name
+
+# Add development dependency
+poetry add --group dev package-name
+```
+
+**Using pip**
+```bash
+# Add to pyproject.toml manually, then update requirements files
+./update-requirements.sh
+```
+
+#### Updating Requirements Files
+
+The `requirements.txt` files are automatically updated by pre-commit hooks when `pyproject.toml` changes. You can also update them manually:
+
+```bash
+# Using the provided script
+./update-requirements.sh
+
+# Or manually with Poetry
+poetry export -f requirements.txt --output requirements.txt
+poetry export -f requirements.txt --output requirements-dev.txt --extras dev
+```
+
+### Installation Options for Contributors
+
+#### Option A: Using pip with requirements.txt
+```bash
+git clone https://github.com/YOUR_USERNAME/fast-clean-architecture.git
+cd fast-clean-architecture
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+pip install -r requirements-dev.txt
+```
+
+#### Option B: Using Poetry (Recommended)
+```bash
+git clone https://github.com/YOUR_USERNAME/fast-clean-architecture.git
+cd fast-clean-architecture
+poetry install --extras dev
+poetry shell
+```
+
 ## Code Style
 
 We use several tools to maintain code quality:
@@ -294,7 +356,7 @@ Use pytest fixtures for common test setup:
 @pytest.fixture
 def temp_project(tmp_path):
     """Create a temporary project structure for testing."""
-    config_path = tmp_path / "fca-config.yaml"
+    config_path = tmp_path / "fca_config.yaml"
     config_path.write_text("""
 project:
   name: test-project

fast_clean_architecture-1.1.0/docs/DEPENDENCY_INJECTION_GUIDE.md

@@ -0,0 +1,311 @@
+# Dependency Injection and Factory Pattern Guide
+
+This guide demonstrates the implementation of dependency injection and factory patterns in Fast Clean Architecture, providing better testability, loose coupling, and maintainable code.
+
+## Overview
+
+The Fast Clean Architecture now implements:
+
+1. **Dependency Injection Pattern**: Components receive their dependencies through constructor injection rather than creating them internally
+2. **Factory Pattern**: A centralized factory creates generators with proper dependency injection
+3. **Protocol-Based Design**: All dependencies are defined through protocols for better type safety
+
+## Architecture Improvements
+
+### Before: Tight Coupling
+
+```python
+# Old approach - tight coupling
+class ComponentGenerator:
+    def __init__(self, config: Config):
+        self.config = config
+        # Direct instantiation creates tight coupling
+        self.validator = TemplateValidator()  # Hard dependency
+        self.path_handler = SecurePathHandler()  # Hard dependency
+```
+
+### After: Dependency Injection
+
+```python
+# New approach - loose coupling through dependency injection
+class ComponentGenerator:
+    def __init__(
+        self, 
+        config: Config, 
+        template_validator: Optional[TemplateValidatorProtocol] = None,
+        path_handler: Optional[SecurePathHandler] = None,
+        console: Optional[Console] = None
+    ):
+        """Initialize ComponentGenerator with dependency injection.
+        
+        Args:
+            config: Configuration object
+            template_validator: Template validator (injected dependency)
+            path_handler: Secure path handler (injected dependency)
+            console: Console for output
+        """
+        self.config = config
+        self.console = console or Console()
+        
+        # Use injected dependencies or create defaults for backward compatibility
+        self.template_validator = template_validator or self._create_default_validator()
+        self.path_handler = path_handler or self._create_default_path_handler()
+```
+
+## Factory Pattern Implementation
+
+### Generator Factory
+
+The `GeneratorFactory` provides a centralized way to create generators with proper dependency injection:
+
+```python
+from fast_clean_architecture.generators import create_generator_factory
+from fast_clean_architecture.config import Config
+
+# Create factory with dependencies
+config = Config.load_from_file('fca_config.yaml')
+factory = create_generator_factory(config)
+
+# Create generators using the factory
+component_generator = factory.create_generator('component')
+package_generator = factory.create_generator('package')
+config_updater = factory.create_generator('config', config_path=Path('custom_config.yaml'))
+```
+
+### Dependency Container
+
+The `DependencyContainer` manages the lifecycle of shared dependencies:
+
+```python
+from fast_clean_architecture.generators.generator_factory import DependencyContainer, GeneratorFactory
+
+# Create dependency container
+dependencies = DependencyContainer(config, console)
+
+# Create factory with dependency container
+factory = GeneratorFactory(dependencies)
+
+# All generators created by this factory will share the same dependencies
+gen1 = factory.create_generator('component')
+gen2 = factory.create_generator('component')
+# Both generators share the same template validator and path handler instances
+```
+
+## Benefits
+
+### 1. Improved Testability
+
+```python
+# Easy to mock dependencies for testing
+from unittest.mock import Mock
+
+mock_validator = Mock(spec=TemplateValidatorProtocol)
+mock_path_handler = Mock(spec=SecurePathHandler)
+
+# Inject mocks for testing
+generator = ComponentGenerator(
+    config=test_config,
+    template_validator=mock_validator,
+    path_handler=mock_path_handler
+)
+
+# Test with controlled dependencies
+generator.create_component(...)
+mock_validator.validate.assert_called_once()
+```
+
+### 2. Flexible Configuration
+
+```python
+# Custom validator for specific use cases
+class StrictTemplateValidator(TemplateValidatorProtocol):
+    def validate(self, template_source: str, template_vars: Dict[str, Any]) -> None:
+        # Custom strict validation logic
+        pass
+
+# Use custom validator
+custom_validator = StrictTemplateValidator()
+generator = ComponentGenerator(
+    config=config,
+    template_validator=custom_validator
+)
+```
+
+### 3. Resource Management
+
+```python
+# Shared dependencies reduce resource usage
+factory = create_generator_factory(config)
+
+# Multiple generators share the same validator and path handler
+for i in range(10):
+    generator = factory.create_generator('component')
+    # All generators use the same validator instance
+```
+
+## Usage Examples
+
+### Basic Usage (Backward Compatible)
+
+```python
+# Still works - uses default dependencies
+from fast_clean_architecture.generators import ComponentGenerator
+from fast_clean_architecture.config import Config
+
+config = Config.load_from_file('fca_config.yaml')
+generator = ComponentGenerator(config)
+```
+
+### Factory Pattern Usage
+
+```python
+# Recommended approach - uses factory
+from fast_clean_architecture.generators import create_generator_factory
+
+factory = create_generator_factory(config)
+component_generator = factory.create_generator('component')
+package_generator = factory.create_generator('package')
+```
+
+### Custom Dependencies
+
+```python
+# Advanced usage - custom dependencies
+from fast_clean_architecture.generators.generator_factory import DependencyContainer, GeneratorFactory
+from fast_clean_architecture.protocols import SecurePathHandler
+
+# Create custom path handler with different settings
+custom_path_handler = SecurePathHandler(
+    max_path_length=8192,  # Longer paths allowed
+    allowed_extensions=['.py', '.j2', '.yaml', '.yml', '.json', '.txt']
+)
+
+# Create dependency container
+dependencies = DependencyContainer(config, console)
+
+# Override default path handler
+dependencies._path_handler = custom_path_handler
+
+# Create factory with custom dependencies
+factory = GeneratorFactory(dependencies)
+generator = factory.create_generator('component')
+```
+
+### CLI Integration
+
+The CLI now uses the factory pattern internally:
+
+```python
+# In CLI code
+config_updater = ConfigUpdater(config_path, console)
+generator_factory = create_generator_factory(config_updater.config, console)
+component_generator = generator_factory.create_generator('component')
+```
+
+## Protocol-Based Design
+
+All dependencies are defined through protocols for better type safety:
+
+```python
+from fast_clean_architecture.protocols import (
+    ComponentGeneratorProtocol,
+    TemplateValidatorProtocol,
+    SecurePathHandler
+)
+
+# Type-safe dependency injection
+def create_custom_generator(
+    config: Config,
+    validator: TemplateValidatorProtocol,
+    path_handler: SecurePathHandler
+) -> ComponentGeneratorProtocol:
+    return ComponentGenerator(
+        config=config,
+        template_validator=validator,
+        path_handler=path_handler
+    )
+```
+
+## Migration Guide
+
+### For Existing Code
+
+1. **No changes required**: Existing code continues to work due to backward compatibility
+2. **Gradual migration**: Replace direct instantiation with factory pattern over time
+3. **Testing improvements**: Start using dependency injection in tests immediately
+
+### Recommended Migration Steps
+
+1. **Update imports**:
+   ```python
+   # Old
+   from fast_clean_architecture.generators import ComponentGenerator
+   
+   # New
+   from fast_clean_architecture.generators import create_generator_factory
+   ```
+
+2. **Replace instantiation**:
+   ```python
+   # Old
+   generator = ComponentGenerator(config, console)
+   
+   # New
+   factory = create_generator_factory(config, console)
+   generator = factory.create_generator('component')
+   ```
+
+3. **Update tests**:
+   ```python
+   # Old
+   generator = ComponentGenerator(config)
+   
+   # New - with mocked dependencies
+   generator = ComponentGenerator(
+       config=config,
+       template_validator=mock_validator,
+       path_handler=mock_path_handler
+   )
+   ```
+
+## Best Practices
+
+1. **Use the factory pattern** for creating generators in application code
+2. **Use dependency injection** for testing and custom configurations
+3. **Leverage protocols** for type safety and interface contracts
+4. **Share dependencies** through the dependency container for resource efficiency
+5. **Mock dependencies** in tests for better isolation and control
+
+## Error Handling
+
+The factory pattern includes proper error handling:
+
+```python
+try:
+    generator = factory.create_generator('invalid_type')
+except ValueError as e:
+    print(f"Error: {e}")  # "Unsupported generator type: invalid_type"
+
+# Check available types
+available_types = factory.get_available_types()
+print(f"Available generator types: {available_types}")
+```
+
+## Extending the Factory
+
+You can register custom generator types:
+
+```python
+class CustomGenerator:
+    def __init__(self, config: Config, console: Console):
+        self.config = config
+        self.console = console
+
+# Register custom generator
+factory.register_generator('custom', CustomGenerator)
+
+# Use custom generator
+custom_gen = factory.create_generator('custom')
+```
+
+This architecture provides a solid foundation for maintainable, testable, and extensible code while maintaining backward compatibility with existing implementations.