cdk-factory 0.18.12__tar.gz → 0.18.19__tar.gz

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.18.12
+Version: 0.18.19
 Summary: CDK Factory. A QuickStarter and best practices setup for CDK projects
 Author-email: Eric Wilson <eric.wilson@geekcafe.com>
 License: MIT License

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/pyproject.toml

@@ -33,7 +33,7 @@ markers = [
 [project]
 
 name = "cdk_factory"
-version = "0.18.12"
+version = "0.18.19"
 authors = [
   { name="Eric Wilson", email="eric.wilson@geekcafe.com" }
 ]

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/src/cdk_factory/configurations/resources/ecs_service.py

@@ -83,14 +83,27 @@ class EcsServiceConfig:
         """Whether to assign public IP addresses"""
         return self._config.get("assign_public_ip", False)
 
+    @property
+    def load_balancer_config(self) -> Dict[str, Any]:
+        """Load balancer configuration"""
+        return self._config.get("load_balancer", {})
+
     @property
     def target_group_arns(self) -> List[str]:
         """Target group ARNs for load balancing"""
+        # Check if load_balancer config has target_group_arn
+        if self.load_balancer_config and self.load_balancer_config.get("target_group_arn"):
+            arn = self.load_balancer_config["target_group_arn"]
+            if arn and arn != "arn:aws:elasticloadbalancing:placeholder":
+                return [arn]
         return self._config.get("target_group_arns", [])
 
     @property
     def container_port(self) -> int:
         """Container port for load balancer"""
+        # Check load_balancer config first
+        if self.load_balancer_config and self.load_balancer_config.get("container_port"):
+            return self.load_balancer_config["container_port"]
         return self._config.get("container_port", 80)
 
     @property
@@ -138,8 +151,17 @@ class EcsServiceConfig:
         """SSM parameter imports"""
         # 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.ssm.get("imports", {})
+            imports = self._config["ssm"]["imports"]
+        else:
+            imports = self.ssm.get("imports", {})
+        
+        # Add load_balancer SSM imports if they exist
+        if self.load_balancer_config and "ssm" in self.load_balancer_config:
+            lb_ssm = self.load_balancer_config["ssm"]
+            if "imports" in lb_ssm:
+                imports.update(lb_ssm["imports"])
+        
+        return imports
 
     @property
     def deployment_type(self) -> str:

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/src/cdk_factory/configurations/resources/route53.py

@@ -106,3 +106,8 @@ class Route53Config:
     def tags(self) -> Dict[str, str]:
         """Tags to apply to the Route53 resources"""
         return self.__config.get("tags", {})
+    
+    @property
+    def records(self) -> List[Dict[str, Any]]:
+        """Records to create"""
+        return self.__config.get("records", [])

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/src/cdk_factory/interfaces/standardized_ssm_mixin.py

@@ -119,6 +119,7 @@ class StandardizedSsmMixin:
         """Export multiple resource values to SSM Parameter Store."""
         params = {}
         
+        invalid_export_keys = []
         # Only export parameters that are explicitly configured in ssm_exports
         if not hasattr(config, 'ssm_exports') or not config.ssm_exports:
             logger.debug("No SSM exports configured")
@@ -138,8 +139,17 @@ class StandardizedSsmMixin:
                 )
                 params[key] = param
             else:
+                invalid_export_keys.append(key)
                 logger.warning(f"SSM export configured for '{key}' but no value found in resource_values")
         
+        if invalid_export_keys:
+            message = f"Export SSM Error\n🚨 SSM exports configured for '{invalid_export_keys}' but no values found in resource_values"
+            available_keys = list(resource_values.keys())
+            message = f"{message}\n✅ Available keys: {available_keys}"
+            message = f"{message}\n👉 Please update to the correct key or remove from the export list."
+            logger.warning(message)
+            raise ValueError(message)
+            
         return params
 
     def normalize_resource_name(self, name: str, for_export: bool = False) -> str:
@@ -269,6 +279,23 @@ class StandardizedSsmMixin:
         
         return exported_params
     
+    def resolve_ssm_value(self, scope: Construct, value: str, unique_id: str)-> str:
+        if isinstance(value, str) and value.startswith("{{ssm:") and value.endswith("}}"):
+            # Extract SSM parameter path
+            ssm_param_path = value[6:-2]  # Remove {{ssm: and }}
+            
+            # Import SSM parameter - this creates a token that resolves at deployment time
+            param = ssm.StringParameter.from_string_parameter_name(
+                scope=scope,
+                id=f"{unique_id}-env-{hash(ssm_param_path) % 10000}",
+                string_parameter_name=ssm_param_path
+            )
+            resolved_value = param.string_value
+            logger.info(f"Resolved SSM parameter {ssm_param_path}")
+            return resolved_value
+        else:
+            return value
+
     def _resolve_ssm_import(self, import_value: Union[str, List[str]], import_key: str) -> Union[str, List[str]]:
         """
         Resolve SSM import value with proper error handling and validation.

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/src/cdk_factory/stack_library/cloudfront/cloudfront_stack.py

@@ -13,6 +13,7 @@ from aws_cdk import (
     aws_cloudfront as cloudfront,
     aws_cloudfront_origins as origins,
     aws_certificatemanager as acm,
+    aws_route53 as route53,
     aws_lambda as _lambda,
     aws_ssm as ssm,
     CfnOutput,
@@ -173,14 +174,18 @@ class CloudFrontStack(IStack):
                 return
             
             # Create the certificate
+            # Get hosted zone from SSM imports
+            hosted_zone_id = cert_config.get("hosted_zone_id")
+            hosted_zone = route53.HostedZone.from_hosted_zone_id(
+                self, "HostedZone", hosted_zone_id
+            )
+            
             self.certificate = acm.Certificate(
                 self,
                 "Certificate",
                 domain_name=domain_name,
                 subject_alternative_names=self.cf_config.aliases,
-                validation_method=acm.ValidationMethod.from_string(
-                    cert_config.get("validation_method", "DNS")
-                ),
+                validation=acm.CertificateValidation.from_dns(hosted_zone=hosted_zone),
             )
             logger.info(f"Created new ACM certificate for domain: {domain_name}")
             return

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/src/cdk_factory/stack_library/ecs/ecs_service_stack.py

@@ -563,7 +563,7 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         for param_key, param_name in ssm_imports.items():
             if 'target_group' in param_key.lower() or 'tg' in param_key.lower():
                 try:
-                    param_value = self.get_ssm_parameter_value(param_name)
+                    param_value = self.get_ssm_imported_value(param_name)
                     if param_value and param_value.startswith('arn:'):
                         target_group_arns.append(param_value)
                 except Exception as e:

{cdk_factory-0.18.12 → cdk_factory-0.18.19}/src/cdk_factory/stack_library/load_balancer/load_balancer_stack.py

@@ -456,44 +456,42 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
             # Configure conditions
             conditions = []
 
-            # Path patterns
-            path_patterns = rule_config.get("path_patterns", [])
-            if path_patterns:
-                conditions.append(elbv2.ListenerCondition.path_patterns(path_patterns))
-
-            # Host headers
-            host_headers = rule_config.get("host_headers", [])
-            if host_headers:
-                conditions.append(elbv2.ListenerCondition.host_headers(host_headers))
-
-            # HTTP headers
-            http_headers = rule_config.get("http_headers", {})
-            for header_name, header_values in http_headers.items():
-                conditions.append(
-                    elbv2.ListenerCondition.http_header(header_name, header_values)
-                )
-
-            # Query strings
-            query_strings = rule_config.get("query_strings", [])
-            if query_strings:
-                query_string_conditions = []
-                for qs in query_strings:
-                    query_string_conditions.append(
-                        elbv2.QueryStringCondition(
-                            key=qs.get("key"), value=qs.get("value")
+            # Parse AWS ALB conditions format
+            aws_conditions = rule_config.get("conditions", [])
+            for condition in aws_conditions:
+                field = condition.get("field")
+                if field == "http-header" and "http_header_config" in condition:
+                    header_config = condition["http_header_config"]
+                    header_name = header_config.get("header_name")
+                    header_values = header_config.get("values", [])
+                    if header_name and header_values:
+                        conditions.append(
+                            elbv2.ListenerCondition.http_header(header_name, header_values)
                         )
-                    )
-                conditions.append(
-                    elbv2.ListenerCondition.query_strings(query_string_conditions)
-                )
+                elif field == "path-pattern" and "values" in condition:
+                    path_patterns = condition.get("values", [])
+                    if path_patterns:
+                        conditions.append(elbv2.ListenerCondition.path_patterns(path_patterns))
+                elif field == "host-header" and "values" in condition:
+                    host_headers = condition.get("values", [])
+                    if host_headers:
+                        conditions.append(elbv2.ListenerCondition.host_headers(host_headers))
 
             # Configure actions
-            target_group_name = rule_config.get("target_group")
-            target_group = (
-                self.target_groups.get(target_group_name) if target_group_name else None
-            )
+            target_group = None
+            
+            # Parse AWS ALB actions format
+            aws_actions = rule_config.get("actions", [])
+            for action in aws_actions:
+                if action.get("type") == "forward":
+                    target_group_name = action.get("target_group")
+                    target_group = (
+                        self.target_groups.get(target_group_name) if target_group_name else None
+                    )
+                    break  # Use first forward action
 
-            if target_group:
+            # Validate that we have both conditions and target group before creating rule
+            if target_group and conditions:
                 # Create rule with forward action
                 elbv2.ApplicationListenerRule(
                     self,
@@ -503,6 +501,15 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
                     conditions=conditions,
                     target_groups=[target_group],
                 )
+            elif not conditions:
+                logger.warning(
+                    f"Skipping listener rule '{rule_id}' - no conditions defined. "
+                    f"CDK requires at least one condition for every rule."
+                )
+            elif not target_group:
+                logger.warning(
+                    f"Skipping listener rule '{rule_id}' - no valid target group found."
+                )
 
     def _add_ip_whitelist_rules(
         self,