cdk-factory 0.15.10__py3-none-any.whl → 0.18.9__py3-none-any.whl

cdk_factory/configurations/base_config.py

@@ -17,14 +17,19 @@ class BaseConfig:
     SSM parameter paths can be customized with prefixes and templates at different levels:
     1. Global level: In the workload or deployment config
     2. Stack level: In the stack config
-    3. Resource level: In the resource config (ssm_exports/ssm_imports)
+    3. Resource level: In the resource config (ssm.exports/ssm.imports)
     
     Example configurations:
     ```json
     {
-        "ssm_prefix_template": "/{environment}/{resource_type}/{attribute}",
-        "ssm_exports": {
-            "vpc_id_path": "my-vpc-id"
+        "ssm": {
+            "prefix_template": "/{environment}/{resource_type}/{attribute}",
+            "exports": {
+                "vpc_id": "my-vpc-id"
+            },
+            "imports": {
+                "security_group_id": "/my-app/security-group/id"
+            }
         }
     }
     ```
@@ -57,6 +62,16 @@ class BaseConfig:
         """
         return self.__config
         
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """
+        Get the SSM configuration for this resource.
+        
+        Returns:
+            Dictionary containing SSM configuration with imports/exports
+        """
+        return self.__config.get("ssm", {})
+        
     @property
     def ssm_prefix_template(self) -> str:
         """
@@ -68,7 +83,7 @@ class BaseConfig:
         Returns:
             The SSM parameter prefix template string
         """
-        return self.__config.get("ssm_prefix_template", "/{deployment_name}/{resource_type}/{attribute}")
+        return self.ssm.get("prefix_template", "/{deployment_name}/{resource_type}/{attribute}")
     
     @property
     def ssm_exports(self) -> Dict[str, str]:
@@ -87,7 +102,7 @@ class BaseConfig:
         Returns:
             Dictionary mapping attribute names to SSM parameter paths for export
         """
-        return self.__config.get("ssm_exports", {})
+        return self.ssm.get("exports", {})
     
     @property
     def ssm_imports(self) -> Dict[str, str]:
@@ -106,25 +121,9 @@ class BaseConfig:
         Returns:
             Dictionary mapping attribute names to SSM parameter paths for import
         """
-        return self.__config.get("ssm_imports", {})
-        
-    @property
-    def ssm_parameters(self) -> Dict[str, str]:
-        """
-        Get all SSM parameter path mappings (both exports and imports).
-        
-        This is provided for backward compatibility.
-        New code should use ssm_exports and ssm_imports instead.
-        
-        Returns:
-            Dictionary mapping attribute names to SSM parameter paths
-        """
-        # Merge exports and imports, with exports taking precedence
-        combined = {**self.ssm_imports, **self.ssm_exports}
-        # Also include any parameters directly under ssm_parameters for backward compatibility
-        combined.update(self.__config.get("ssm_parameters", {}))
-        return combined
+        return self.ssm.get("imports", {})
         
+            
     def get(self, key: str, default: Any = None) -> Any:
         """
         Get a configuration value by key.

cdk_factory/configurations/cdk_config.py

@@ -183,11 +183,13 @@ class CdkConfig:
         if self._resolved_config_file_path is None:
             raise ValueError("Config file path is not set")
 
-        file_name = f".dynamic_{os.path.basename(self._resolved_config_file_path)}"
+        file_name = os.path.join(".dynamic", os.path.basename(self._resolved_config_file_path))
         path = os.path.join(Path(self._resolved_config_file_path).parent, file_name)
-
+        
+        if not os.path.exists(Path(path).parent):
+            os.makedirs(Path(path).parent)
         cdk = config.get("cdk", {})
-        if replacements and len(replacements) > 0:
+        if replacements:
             config = JsonLoadingUtility.recursive_replace(config, replacements)
             print(f"📀 Saving config to {path}")
             # add the original cdk back
@@ -214,7 +216,7 @@ class CdkConfig:
             value = static_value
         elif environment_variable_name is not None and not value:
             value = os.environ.get(environment_variable_name, None)
-            if value is None and required:
+            if (value is None or str(value).strip() == "") and required:
                 raise ValueError(
                     f"Failed to get value for environment variable {environment_variable_name}"
                 )

cdk_factory/configurations/deployment.py

@@ -28,6 +28,18 @@ class DeploymentConfig:
         self.__load()
 
     def __load(self):
+        # Validate environment consistency
+        deployment_env = self.__deployment.get("environment")
+        workload_env = self.__workload.get("environment")
+        
+        if deployment_env and workload_env and deployment_env != workload_env:
+            from aws_lambda_powertools import Logger
+            logger = Logger()
+            logger.warning(
+                f"Environment mismatch: deployment.environment='{deployment_env}' != workload.environment='{workload_env}'. "
+                f"Using workload.environment for consistency."
+            )
+        
         self.__load_pipeline()
         self.__load_stacks()
 

cdk_factory/configurations/devops.py

@@ -64,7 +64,7 @@ class DevOps:
             )
             if (
                 not self.__code_repository.repository
-                or len(self.__code_repository.repository) == 0
+                or not self.__code_repository.repository
             ):
                 raise ValueError(
                     "Code Repository is not defined in the configuration "

cdk_factory/configurations/pipeline_stage.py

@@ -117,8 +117,32 @@ class PipelineStageConfig:
     @property
     def builds(self) -> List[Dict[str, Any]]:
         """
-        Returns the stages for this pipeline
-        """
-        builds = self.workload.get("builds", [])
-
-        return builds
+        Returns the builds configured for this stage.
+        
+        If the stage has a "builds" array of strings, resolve them to the
+        corresponding build objects defined at workload["builds"].
+        Otherwise, return an empty list.
+        """
+        stage_build_refs = self.dictionary.get("builds", [])
+        if not stage_build_refs:
+            return []
+
+        workload_builds: List[Dict[str, Any]] = self.workload.get("builds", [])
+        by_name: Dict[str, Dict[str, Any]] = {}
+        for b in workload_builds:
+            name = b.get("name") or b.get("id")
+            if name:
+                by_name[name] = b
+
+        resolved: List[Dict[str, Any]] = []
+        for ref in stage_build_refs:
+            if isinstance(ref, str):
+                if ref in by_name:
+                    resolved.append(by_name[ref])
+                else:
+                    raise ValueError(f"Build '{ref}' referenced by stage '{self.name}' not found in workload.builds")
+            elif isinstance(ref, dict):
+                # Allow inline build definitions at the stage level as a fallback
+                resolved.append(ref)
+
+        return resolved

cdk_factory/configurations/resources/acm.py

@@ -0,0 +1,85 @@
+"""
+AcmConfig - supports ACM (AWS Certificate Manager) settings for AWS CDK.
+Maintainers: Eric Wilson
+MIT License. See Project Root for license information.
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+class AcmConfig:
+    """
+    ACM Configuration - supports AWS Certificate Manager settings.
+    Each property reads from the config dict and provides a sensible default if not set.
+    """
+
+    def __init__(self, config: dict = None, deployment=None) -> None:
+        self.__config = config or {}
+        self.__deployment = deployment
+
+    @property
+    def name(self) -> str:
+        """Certificate configuration name"""
+        return self.__config.get("name", "certificate")
+
+    @property
+    def domain_name(self) -> str:
+        """Primary domain name for the certificate"""
+        domain = self.__config.get("domain_name")
+        if not domain:
+            raise ValueError("domain_name is required for ACM certificate")
+        return domain
+
+    @property
+    def subject_alternative_names(self) -> List[str]:
+        """Subject alternative names (SANs) for the certificate"""
+        sans = self.__config.get("subject_alternative_names", [])
+        # Also check for alternate_names for backward compatibility
+        if not sans:
+            sans = self.__config.get("alternate_names", [])
+        return sans
+
+    @property
+    def hosted_zone_id(self) -> Optional[str]:
+        """Route53 hosted zone ID for DNS validation"""
+        return self.__config.get("hosted_zone_id")
+
+    @property
+    def hosted_zone_name(self) -> Optional[str]:
+        """Route53 hosted zone name (used for looking up zone)"""
+        return self.__config.get("hosted_zone_name")
+
+    @property
+    def validation_method(self) -> str:
+        """Certificate validation method (DNS or EMAIL)"""
+        return self.__config.get("validation_method", "DNS")
+
+    @property
+    def certificate_transparency_logging_preference(self) -> Optional[str]:
+        """Certificate transparency logging preference (ENABLED or DISABLED)"""
+        return self.__config.get("certificate_transparency_logging_preference")
+
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """SSM configuration for importing/exporting resources"""
+        return self.__config.get("ssm", {})
+
+    @property
+    def ssm_exports(self) -> Dict[str, str]:
+        """SSM parameter paths to export certificate details"""
+        exports = self.ssm.get("exports", {})
+        
+        # Provide default SSM export path if not specified
+        if not exports and self.__deployment:
+            workload_env = self.__deployment.workload.get("environment", self.__deployment.environment)
+            workload_name = self.__deployment.workload.get("name", self.__deployment.workload_name)
+            exports = {
+                "certificate_arn": f"/{workload_env}/{workload_name}/certificate/arn"
+            }
+        
+        return exports
+
+    @property
+    def tags(self) -> Dict[str, str]:
+        """Tags to apply to the certificate"""
+        return self.__config.get("tags", {})

cdk_factory/configurations/resources/auto_scaling.py

@@ -70,12 +70,9 @@ class AutoScalingConfig(EnhancedBaseConfig):
         return self.__config.get("termination_policies", ["DEFAULT"])
 
     @property
-    def update_policy(self) -> Dict[str, Any]:
+    def update_policy(self) -> Optional[Dict[str, Any]]:
         """Update policy configuration"""
-        return self.__config.get(
-            "update_policy",
-            {"min_instances_in_service": 1, "max_batch_size": 1, "pause_time": 300},
-        )
+        return self.__config.get("update_policy")
 
     @property
     def user_data_commands(self) -> List[str]:
@@ -175,3 +172,8 @@ class AutoScalingConfig(EnhancedBaseConfig):
     def key_name(self) -> Optional[str]:
         """EC2 key pair name for SSH access"""
         return self.__config.get("key_name")
+
+    @property
+    def ssm_imports(self) -> Dict[str, Any]:
+        """SSM imports for the Auto Scaling Group"""
+        return self.__config.get("ssm", {}).get("imports", {})

cdk_factory/configurations/resources/cloudfront.py

@@ -102,15 +102,20 @@ class CloudFrontConfig(EnhancedBaseConfig):
         """Resource tags"""
         return self._config.get("tags", {})
 
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """SSM configuration"""
+        return self._config.get("ssm", {})
+
     @property
     def ssm_exports(self) -> Dict[str, str]:
         """SSM parameter exports"""
-        return self._config.get("ssm_exports", {})
+        return self.ssm.get("exports", {})
 
     @property
     def ssm_imports(self) -> Dict[str, str]:
         """SSM parameter imports"""
-        return self._config.get("ssm_imports", {})
+        return self.ssm.get("imports", {})
 
     @property
     def hosted_zone_id(self) -> str:

cdk_factory/configurations/resources/ecr.py

@@ -128,7 +128,7 @@ class ECRConfig(EnhancedBaseConfig):
         Example:
         {
             "enabled": true,
-            "accounts": ["123456789012", "987654321098"],
+            "accounts": [os.environ.get("ECR_ALLOWED_ACCOUNT_1"), os.environ.get("ECR_ALLOWED_ACCOUNT_2")],
             "services": [
                 {
                     "name": "lambda",

cdk_factory/configurations/resources/ecs_cluster.py

@@ -0,0 +1,108 @@
+"""
+ECS Cluster Configuration
+
+Defines the configuration schema for ECS cluster stacks.
+"""
+
+from typing import Optional, Dict, Any, List
+
+
+class EcsClusterConfig:
+    """
+    Configuration for an ECS cluster.
+    
+    This class defines all the configurable parameters for an ECS cluster,
+    providing explicit control over cluster creation and settings.
+    """
+    
+    def __init__(self, config: Dict[str, Any]) -> None:
+        self._config = config or {}
+    
+    @property
+    def dictionary(self) -> Dict[str, Any]:
+        """Access to the underlying configuration dictionary (for compatibility with SSM mixin)"""
+        return self._config
+    
+    @property
+    def name(self) -> str:
+        """Name of the ECS cluster. Supports template variables like {{WORKLOAD_NAME}}-{{ENVIRONMENT}}-cluster"""
+        return self._config.get("name", "cluster")
+    
+    @property
+    def container_insights(self) -> bool:
+        """Enable container insights for the cluster"""
+        return self._config.get("container_insights", True)
+    
+    @property
+    def cluster_settings(self) -> Optional[List[Dict[str, str]]]:
+        """Additional cluster settings as name-value pairs"""
+        return self._config.get("cluster_settings")
+    
+    @property
+    def cloud_map_namespace(self) -> Optional[Dict[str, Any]]:
+        """Cloud Map namespace configuration for service discovery"""
+        return self._config.get("cloud_map_namespace")
+    
+    @property
+    def execute_command_configuration(self) -> Optional[Dict[str, Any]]:
+        """Execute command configuration for ECS"""
+        return self._config.get("execute_command_configuration")
+    
+    @property
+    def vpc_id(self) -> Optional[str]:
+        """VPC ID where the cluster should be created"""
+        return self._config.get("vpc_id")
+    
+    @property
+    def ssm_vpc_id(self) -> Optional[str]:
+        """SSM parameter path to import VPC ID"""
+        return self._config.get("ssm_vpc_id")
+    
+    @property
+    def create_instance_role(self) -> bool:
+        """Whether to create an ECS instance role"""
+        return self._config.get("create_instance_role", True)
+    
+    @property
+    def instance_role_name(self) -> Optional[str]:
+        """Custom name for the ECS instance role"""
+        return self._config.get("instance_role_name")
+    
+    @property
+    def instance_profile_name(self) -> Optional[str]:
+        """Custom name for the ECS instance profile"""
+        return self._config.get("instance_profile_name")
+    
+    @property
+    def managed_policies(self) -> List[str]:
+        """List of AWS managed policies to attach to the instance role"""
+        return self._config.get("managed_policies", [
+            "service-role/AmazonEC2ContainerServiceforEC2Role",
+            "AmazonSSMManagedInstanceCore"
+        ])
+    
+    @property
+    def inline_policies(self) -> Optional[Dict[str, Dict[str, Any]]]:
+        """Inline IAM policies to attach to the instance role"""
+        return self._config.get("inline_policies")
+    
+    @property
+    def export_ssm_parameters(self) -> bool:
+        """Whether to export cluster information to SSM parameters"""
+        return self._config.get("export_ssm_parameters", True)
+
+    
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """SSM configuration"""
+        return self._config.get("ssm", {})
+    
+    @property
+    def ssm_exports(self) -> Dict[str, str]:
+        """SSM parameter exports"""
+        return self.ssm.get("exports", {})
+
+    @property
+    def ssm_imports(self) -> Dict[str, Any]:
+        """SSM parameter imports"""
+        return self.ssm.get("imports", {})

cdk_factory/configurations/resources/ecs_service.py

@@ -123,10 +123,15 @@ class EcsServiceConfig:
         """Resource tags"""
         return self._config.get("tags", {})
 
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """SSM configuration"""
+        return self._config.get("ssm", {})
+
     @property
     def ssm_exports(self) -> Dict[str, str]:
         """SSM parameter exports"""
-        return self._config.get("ssm_exports", {})
+        return self.ssm.get("exports", {})
 
     @property
     def ssm_imports(self) -> Dict[str, Any]:
@@ -134,13 +139,23 @@ class EcsServiceConfig:
         # Check both nested and flat structures for backwards compatibility
         if "ssm" in self._config and "imports" in self._config["ssm"]:
             return self._config["ssm"]["imports"]
-        return self._config.get("ssm_imports", {})
+        return self.ssm.get("imports", {})
 
     @property
     def deployment_type(self) -> str:
         """Deployment type: production, maintenance, or blue-green"""
         return self._config.get("deployment_type", "production")
 
+    @property
+    def deployment_circuit_breaker(self) -> Dict[str, Any]:
+        """Deployment circuit breaker configuration"""
+        return self._config.get("deployment_circuit_breaker", {})
+
+    @property
+    def deployment_configuration(self) -> Dict[str, Any]:
+        """Deployment configuration (maximum_percent, minimum_healthy_percent)"""
+        return self._config.get("deployment_configuration", {})
+
     @property
     def is_maintenance_mode(self) -> bool:
         """Whether this is a maintenance mode deployment"""

cdk_factory/configurations/resources/load_balancer.py

@@ -144,10 +144,23 @@ class LoadBalancerConfig(EnhancedBaseConfig):
             "block_response", default_response
         )
 
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """SSM configuration"""
+        return self.__config.get("ssm", {})
+
     @property
     def ssm_imports(self) -> Dict[str, Any]:
         """SSM parameter imports for the Load Balancer"""
-        # Check both nested and flat structures for backwards compatibility
-        if "ssm" in self.__config and "imports" in self.__config["ssm"]:
-            return self.__config["ssm"]["imports"]
-        return self.__config.get("ssm_imports", {})
+        return self.ssm.get("imports", {})
+
+    @property
+    def ssm_exports(self) -> Dict[str, Any]:
+        """SSM parameter exports for the Load Balancer"""
+        return self.ssm.get("exports", {})
+    
+    @property
+    def ssm_parameters(self) -> Dict[str, Any]:
+        """SSM parameters for the Load Balancer (only exports, not imports)"""
+        # For LoadBalancer, only return exports to prevent trying to export imported values
+        return self.ssm_exports

cdk_factory/configurations/resources/monitoring.py

@@ -18,7 +18,7 @@ class MonitoringConfig(EnhancedBaseConfig):
         super().__init__(
             config or {},
             resource_type="monitoring",
-            resource_name=config.get("name", "monitoring") if config else "monitoring"
+            resource_name=config.get("name", "monitoring") if config else "monitoring",
         )
         self._config = config or {}
         self._deployment = deployment
@@ -63,12 +63,17 @@ class MonitoringConfig(EnhancedBaseConfig):
         """Resource tags"""
         return self._config.get("tags", {})
 
+    @property
+    def ssm(self) -> Dict[str, Any]:
+        """SSM configuration"""
+        return self._config.get("ssm", {})
+
     @property
     def ssm_exports(self) -> Dict[str, str]:
         """SSM parameter exports"""
-        return self._config.get("ssm_exports", {})
+        return self.ssm.get("exports", {})
 
     @property
     def ssm_imports(self) -> Dict[str, str]:
         """SSM parameter imports for resource ARNs"""
-        return self._config.get("ssm_imports", {})
+        return self.ssm.get("imports", {})