cdk-factory 0.17.6__py3-none-any.whl → 0.20.0__py3-none-any.whl

cdk_factory/stack_library/route53/route53_stack.py

@@ -7,10 +7,15 @@ MIT License.  See Project Root for the license information.
 from typing import Dict, Any, List, Optional
 
 import aws_cdk as cdk
-from aws_cdk import aws_route53 as route53
-from aws_cdk import aws_route53_targets as targets
-from aws_cdk import aws_certificatemanager as acm
-from aws_cdk import aws_elasticloadbalancingv2 as elbv2
+from aws_cdk import (
+    aws_route53 as route53,
+    aws_route53_targets as targets,
+    aws_certificatemanager as acm,
+    aws_elasticloadbalancingv2 as elbv2,
+    aws_cloudfront as cloudfront,
+    Duration,
+    CfnOutput,
+)
 from aws_lambda_powertools import Logger
 from constructs import Construct
 
@@ -35,6 +40,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
 
     def __init__(self, scope: Construct, id: str, **kwargs) -> None:
         super().__init__(scope, id, **kwargs)
+        
         self.route53_config = None
         self.stack_config = None
         self.deployment = None
@@ -42,6 +48,7 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         self.hosted_zone = None
         self.certificate = None
         self.records = {}
+        self._distribution_cache = {}  # Cache for reusing distributions
 
     def build(self, stack_config: StackConfig, deployment: DeploymentConfig, workload: WorkloadConfig) -> None:
         """Build the Route53 stack"""
@@ -112,6 +119,232 @@ class Route53Stack(IStack, StandardizedSsmMixin):
         return certificate
 
     def _create_dns_records(self) -> None:
+        self._create_dns_records_old()
+        self._create_dns_records_new()
+
+    
+    def _get_or_create_cloudfront_distribution(self, distribution_domain: str, distribution_id: str) -> cloudfront.Distribution:
+        """Get or create a CloudFront distribution, reusing if already created"""
+        # Create a unique cache key from distribution domain and ID
+        cache_key = f"{distribution_domain}-{distribution_id}"
+        
+        if cache_key not in self._distribution_cache:
+            # Create the distribution construct with a unique ID
+            unique_id = f"CF-{distribution_domain.replace('.', '-').replace('*', 'wildcard')}-{hash(cache_key) % 10000}"
+            distribution = cloudfront.Distribution.from_distribution_attributes(
+                self, unique_id,
+                domain_name=distribution_domain,
+                distribution_id=distribution_id
+            )
+            self._distribution_cache[cache_key] = distribution
+            logger.info(f"Created CloudFront distribution construct for {distribution_domain}")
+        
+        return self._distribution_cache[cache_key]
+
+    def _create_dns_records_new(self) -> None:
+        """Create DNS records based on configuration - generic implementation"""
+        
+        missing_configurations = []
+
+        for record in self.route53_config.records:
+            record_name = record.get("name", "")
+            record_type = record.get("type", "")
+            
+            if not record_name or not record_type:
+                message = f"Record missing name or type: {record}"
+                logger.warning(message)
+                missing_configurations.append(message)
+                continue
+            
+            # Handle alias records
+            if "alias" in record:
+                alias_config = record["alias"]
+                target_type = alias_config.get("target_type", "")
+                target_value = alias_config.get("target_value", "")
+                hosted_zone_id = alias_config.get("hosted_zone_id", "")
+                
+                unique_id = f"{record_name}-{record_type}"
+                # Handle SSM parameter references in target_value                
+                target_value = self.resolve_ssm_value(self, target_value, unique_id=unique_id)
+                
+                if not target_type or not target_value:
+                    message = f"Alias record missing target_type or target_value: {record}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+                
+                # Create appropriate target based on type
+                alias_target = None
+                if target_type == "cloudfront":
+                    # CloudFront distribution target
+                    distribution_domain = target_value
+                    distribution_id = alias_config.get("distribution_id", "")
+                    if not distribution_id:
+                        message = f"Alias record missing distribution_id: {record}"
+                        logger.warning(message)
+                        missing_configurations.append(message)
+                        continue
+                    
+                    # Get or create the distribution (reuses if already created)
+                    distribution = self._get_or_create_cloudfront_distribution(distribution_domain, distribution_id)
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.CloudFrontTarget(distribution)
+                    )
+                elif target_type == "loadbalancer" or target_type == "alb":
+                    # Load Balancer target
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.LoadBalancerTarget(
+                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
+                                self, f"ALB-{record_name}",
+                                load_balancer_dns_name=target_value,
+                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
+                            )
+                        )
+                    )
+                elif target_type == "elbv2":
+                    # Generic ELBv2 target
+                    alias_target = route53.RecordTarget.from_alias(
+                        targets.LoadBalancerTarget(
+                            elbv2.ApplicationLoadBalancer.from_load_balancer_attributes(
+                                self, f"ELB-{record_name}",
+                                load_balancer_dns_name=target_value,
+                                load_balancer_canonical_hosted_zone_id=hosted_zone_id
+                            )
+                        )
+                    )
+                else:
+                    message = f"Unsupported alias target type: {target_type}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+                
+                # Create the alias record
+                route53.ARecord(
+                    self,
+                    f"AliasRecord-{record_name}-{record_type}",
+                    zone=self.hosted_zone,
+                    record_name=record_name,
+                    target=alias_target,
+                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                ) if record_type == "A" else route53.AaaaRecord(
+                    self,
+                    f"AliasRecord-{record_name}-{record_type}",
+                    zone=self.hosted_zone,
+                    record_name=record_name,
+                    target=alias_target,
+                    ttl=cdk.Duration.seconds(record.get("ttl", 300))
+                )
+                
+            # Handle standard records with values
+            elif "values" in record:
+                values = record["values"]
+                if not isinstance(values, list):
+                    values = [values]
+                
+                # Handle SSM parameter references in values
+                processed_values = []
+                for value in values:
+                    if "{{ssm:" in str(value) and "}}" in str(value):
+                        # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
+                        ssm_path = str(value).split("{{ssm:")[1].split("}}")[0]
+                        resolved_value = self.get_ssm_imported_value(ssm_path)
+                        processed_values.append(resolved_value)
+                    else:
+                        processed_values.append(value)
+                
+                values = processed_values
+                ttl = record.get("ttl", 300)
+                
+                # Create standard record based on type
+                if record_type == "A":
+                    route53.ARecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=route53.RecordTarget.from_ip_addresses(*values),
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "AAAA":
+                    route53.AaaaRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        target=route53.RecordTarget.from_ip_addresses(*values),
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "CNAME":
+                    route53.CnameRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        domain_name=values[0],  # CNAME only supports single value
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "MX":
+                    # MX records need special handling for preference values
+                    mx_targets = []
+                    for value in values:
+                        if isinstance(value, str) and " " in value:
+                            preference, domain = value.split(" ", 1)
+                            mx_targets.append(route53.MxRecordValue(
+                                domain_name=domain.strip(),
+                                preference=int(preference.strip())
+                            ))
+                        else:
+                            logger.warning(f"Invalid MX record format: {value}")
+                    
+                    if mx_targets:
+                        route53.MxRecord(
+                            self,
+                            f"Record-{record_name}",
+                            zone=self.hosted_zone,
+                            record_name=record_name,
+                            values=mx_targets,
+                            ttl=cdk.Duration.seconds(ttl)
+                        )
+                elif record_type == "TXT":
+                    route53.TxtRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        values=values,
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                elif record_type == "NS":
+                    route53.NsRecord(
+                        self,
+                        f"Record-{record_name}",
+                        zone=self.hosted_zone,
+                        record_name=record_name,
+                        values=values,
+                        ttl=cdk.Duration.seconds(ttl)
+                    )
+                else:
+                    message = f"Unsupported record type: {record_type}"
+                    logger.warning(message)
+                    missing_configurations.append(message)
+                    continue
+            
+            else:
+                message = f"Record missing 'alias' or 'values' configuration: {record}"
+                logger.warning(message)
+                missing_configurations.append(message)
+                continue
+
+        if missing_configurations and len(missing_configurations) > 0:
+            # print all missing configurations
+            print("Missing configurations:")
+            for message in missing_configurations:
+                print(message)
+            
+            messages = "\n".join(missing_configurations)
+            raise ValueError(f"Missing Configurations:\n{messages}")
+
+    def _create_dns_records_old(self) -> None:
         """Create DNS records based on configuration"""
         # Create alias records
         for alias_record in self.route53_config.aliases:
@@ -119,6 +352,12 @@ class Route53Stack(IStack, StandardizedSsmMixin):
             target_type = alias_record.get("target_type", "")
             target_value = alias_record.get("target_value", "")
             
+            # target value needs to handle SSM parameters
+            if "{{ssm:" in target_value and "}}" in target_value:
+                # Extract SSM parameter path from template like {{ssm:/path/to/parameter}}
+                ssm_path = target_value.split("{{ssm:")[1].split("}}")[0]
+                target_value = self.get_ssm_imported_value(ssm_path)
+
             if not record_name or not target_type or not target_value:
                 continue
                 
@@ -174,37 +413,4 @@ class Route53Stack(IStack, StandardizedSsmMixin):
     def _add_outputs(self) -> None:
         """Add CloudFormation outputs for the Route53 resources"""
         # Hosted Zone ID
-        if self.hosted_zone:
-            cdk.CfnOutput(
-                self,
-                "HostedZoneId",
-                value=self.hosted_zone.hosted_zone_id,
-                export_name=f"{self.deployment.build_resource_name('hosted-zone')}-id"
-            )
-            
-            # Hosted Zone Name Servers
-            if hasattr(self.hosted_zone, "name_servers") and self.hosted_zone.name_servers:
-                cdk.CfnOutput(
-                    self,
-                    "NameServers",
-                    value=",".join(self.hosted_zone.name_servers),
-                    export_name=f"{self.deployment.build_resource_name('hosted-zone')}-name-servers"
-                )
-        
-        # Certificate ARN
-        if self.certificate:
-            cdk.CfnOutput(
-                self,
-                "CertificateArn",
-                value=self.certificate.certificate_arn,
-                export_name=f"{self.deployment.build_resource_name('certificate')}-arn"
-            )
-            
-        # Record names
-        for name, record in self.records.items():
-            cdk.CfnOutput(
-                self,
-                f"Record-{name}",
-                value=name,
-                export_name=f"{self.deployment.build_resource_name('record')}-{name}"
-            )
+        return

cdk_factory/stack_library/rum/rum_stack.py

@@ -72,7 +72,7 @@ class RumStack(IStack, StandardizedSsmMixin):
                     "cognito_identity_pool_id"
                 ] = "/{{ORGANIZATION}}/{{ENVIRONMENT}}/cognito/user-pool/identity-pool-id"
 
-        self.setup_standardized_ssm_integration(
+        self.setup_ssm_integration(
             scope=self,
             config=rum_config,
             resource_type="rum",
@@ -80,7 +80,7 @@ class RumStack(IStack, StandardizedSsmMixin):
         )
 
         # Process SSM imports using standardized method
-        self.process_standardized_ssm_imports()
+        self.process_ssm_imports()
 
         # Import or create Cognito resources
         identity_pool_id, guest_role_arn = self._setup_cognito_integration()
@@ -341,7 +341,7 @@ class RumStack(IStack, StandardizedSsmMixin):
             resource_values["user_pool_id"] = self.user_pool.user_pool_id
 
         # Use enhanced SSM parameter export
-        exported_params = self.export_standardized_ssm_parameters(resource_values)
+        exported_params = self.export_ssm_parameters(resource_values)
 
         if exported_params:
             logger.info(f"Exported {len(exported_params)} RUM parameters to SSM")

cdk_factory/stack_library/security_group/security_group_full_stack.py

@@ -194,37 +194,7 @@ class SecurityGroupsStack(IStack, VPCProviderMixin):
                 description="Uptime Robot",
             )
 
-        # =========================================================
-        # Outputs (exports)
-        # =========================================================
-        cdk.CfnOutput(
-            self,
-            "WebFleetAlbSecurityGroupOut",
-            value=alb_sg.ref,
-            description="Web Fleet Application Load Balancer Security Group",
-            export_name=f"{self.deployment.environment}-{self.workload.name}-WebFleetAlbSecurityGroup",
-        )
-        cdk.CfnOutput(
-            self,
-            "WebFleetInstancesSecurityGroupOut",
-            value=web_fleet_sg.ref,
-            description="Web Fleet Instances Security Group",
-            export_name=f"{self.deployment.environment}-{self.workload.name}-WebFleetInstancesSecurityGroup",
-        )
-        cdk.CfnOutput(
-            self,
-            "MySqlDbSecurityGroupOut",
-            value=mysql_sg.ref,
-            description="MySql Security Group",
-            export_name=f"{self.deployment.environment}-{self.workload.name}-MySqlDbSecurityGroup",
-        )
-        cdk.CfnOutput(
-            self,
-            "WebMonitoringSecurityGroupOut",
-            value=monitoring_sg.ref,
-            description="Web Fleet Application Load Balancer Security Group",
-            export_name=f"{self.deployment.environment}-{self.workload.name}-WebMonitoringSecurityGroup",
-        )
+       
 
         # =========================================================
         # SSM Parameter Store Exports

cdk_factory/stack_library/security_group/security_group_stack.py

@@ -337,14 +337,7 @@ class SecurityGroupStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
     def _export_cfn_outputs(self, sg_name: str) -> None:
         """Add CloudFormation outputs for the Security Group"""
-        if self.security_group:
-            # Security Group ID
-            cdk.CfnOutput(
-                self,
-                f"{sg_name}-id",
-                value=self.security_group.security_group_id,
-                export_name=f"{self.deployment.build_resource_name(sg_name)}-id",
-            )
+        return
 
     def _export_ssm_parameters(self, sg_name: str) -> None:
         """Add SSM parameters for the Security Group"""

cdk_factory/stack_library/simple_queue_service/sqs_stack.py

@@ -131,37 +131,4 @@ class SQSStack(IStack):
 
     def _add_outputs(self) -> None:
         """Add CloudFormation outputs for the SQS queues"""
-        for queue_name, queue in self.queues.items():
-            # Queue ARN
-            cdk.CfnOutput(
-                self,
-                f"{queue_name}-arn",
-                value=queue.queue_arn,
-                export_name=f"{self.deployment.build_resource_name(queue_name)}-arn"
-            )
-            
-            # Queue URL
-            cdk.CfnOutput(
-                self,
-                f"{queue_name}-url",
-                value=queue.queue_url,
-                export_name=f"{self.deployment.build_resource_name(queue_name)}-url"
-            )
-        
-        # Also add outputs for DLQs
-        for dlq_name, dlq in self.dead_letter_queues.items():
-            # DLQ ARN
-            cdk.CfnOutput(
-                self,
-                f"{dlq_name}-arn",
-                value=dlq.queue_arn,
-                export_name=f"{self.deployment.build_resource_name(dlq_name)}-arn"
-            )
-            
-            # DLQ URL
-            cdk.CfnOutput(
-                self,
-                f"{dlq_name}-url",
-                value=dlq.queue_url,
-                export_name=f"{self.deployment.build_resource_name(dlq_name)}-url"
-            )
+        return

cdk_factory/stack_library/stack_base.py

@@ -54,6 +54,11 @@ class StackStandards:
         git_hash = GitUtilities.get_git_commit_hash()
         if git_hash:
             aws_cdk.Tags.of(scope).add("ApplicationGitHash", git_hash)
+        
+        # Add CDK Factory version for tracking and debugging
+        from cdk_factory.version import __version__
+        aws_cdk.Tags.of(scope).add("CdkFactoryVersion", __version__)
+        
         aws_cdk.Tags.of(scope).add(
             "DeploymentDateUTC", str(datetime.datetime.now(datetime.UTC))
         )

cdk_factory/stack_library/vpc/{vpc_stack_standardized.py → vpc_stack.py}

@@ -74,7 +74,7 @@ class VpcStack(IStack, StandardizedSsmMixin):
         vpc_name = deployment.build_resource_name(self.vpc_config.name)
 
         # Setup standardized SSM integration
-        self.setup_standardized_ssm_integration(
+        self.setup_ssm_integration(
             scope=self,
             config=self.vpc_config,
             resource_type="vpc",
@@ -84,7 +84,7 @@ class VpcStack(IStack, StandardizedSsmMixin):
         )
 
         # Process SSM imports using standardized method
-        self.process_standardized_ssm_imports()
+        self.process_ssm_imports()
 
         # Import any required resources from SSM
         imported_resources = self.get_all_ssm_imports()
@@ -241,111 +241,8 @@ class VpcStack(IStack, StandardizedSsmMixin):
 
     def _add_outputs(self, vpc_name: str) -> None:
         """Add CloudFormation outputs for the VPC"""
-        if not self.vpc:
-            return
-            
-        # VPC outputs
-        cdk.CfnOutput(
-            self,
-            f"{vpc_name}-VpcId",
-            value=self.vpc.vpc_id,
-            description=f"VPC ID for {vpc_name}",
-            export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-vpc-id",
-        )
-        
-        # Subnet outputs
-        public_subnet_ids = [subnet.subnet_id for subnet in self.vpc.public_subnets]
-        if public_subnet_ids:
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-PublicSubnetIds",
-                value=",".join(public_subnet_ids),
-                description=f"Public subnet IDs for {vpc_name}",
-                export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-public-subnet-ids",
-            )
-        
-        private_subnet_ids = [subnet.subnet_id for subnet in self.vpc.private_subnets]
-        if private_subnet_ids:
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-PrivateSubnetIds",
-                value=",".join(private_subnet_ids),
-                description=f"Private subnet IDs for {vpc_name}",
-                export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-private-subnet-ids",
-            )
-        
-        isolated_subnet_ids = [subnet.subnet_id for subnet in self.vpc.isolated_subnets]
-        if isolated_subnet_ids:
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-IsolatedSubnetIds",
-                value=",".join(isolated_subnet_ids),
-                description=f"Isolated subnet IDs for {vpc_name}",
-                export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-isolated-subnet-ids",
-            )
-        
-        # Route table outputs - simplified to avoid route table access issues
-        # Skip route table outputs for now as they're causing CDK API issues
-        # public_route_table_ids = []
-        # if self.vpc.public_subnets:
-        #     for subnet in self.vpc.public_subnets:
-        #         # Access route table through the subnet's route table association
-        #         for association in subnet.node.children:
-        #             if hasattr(association, 'route_table_id') and association.route_table_id:
-        #                 public_route_table_ids.append(association.route_table_id)
-        # 
-        # if public_route_table_ids:
-        #     cdk.CfnOutput(
-        #         self,
-        #         f"{vpc_name}-PublicRouteTableIds",
-        #         value=",".join(public_route_table_ids),
-        #         description=f"Public route table IDs for {vpc_name}",
-        #         export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-public-route-table-ids",
-        #     )
-        # 
-        # private_route_table_ids = []
-        # if self.vpc.private_subnets:
-        #     for subnet in self.vpc.private_subnets:
-        #         # Access route table through the subnet's route table association
-        #         for association in subnet.node.children:
-        #             if hasattr(association, 'route_table_id') and association.route_table_id:
-        #                 private_route_table_ids.append(association.route_table_id)
-        # 
-        # if private_route_table_ids:
-        #     cdk.CfnOutput(
-        #         self,
-        #         f"{vpc_name}-PrivateRouteTableIds",
-        #         value=",".join(private_route_table_ids),
-        #         description=f"Private route table IDs for {vpc_name}",
-        #         export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-private-route-table-ids",
-        #     )
-        
-        # Internet Gateway output
-        if hasattr(self.vpc, 'internet_gateway_id') and self.vpc.internet_gateway_id:
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-InternetGatewayId",
-                value=self.vpc.internet_gateway_id,
-                description=f"Internet Gateway ID for {vpc_name}",
-                export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-internet-gateway-id",
-            )
-        
-        # NAT Gateway outputs - simplified to avoid None values
-        nat_gateway_ids = []
-        for subnet in self.vpc.public_subnets:
-            if hasattr(subnet, 'node') and subnet.node:
-                for child in subnet.node.children:
-                    if hasattr(child, 'nat_gateway_id') and child.nat_gateway_id:
-                        nat_gateway_ids.append(child.nat_gateway_id)
-        
-        if nat_gateway_ids:
-            cdk.CfnOutput(
-                self,
-                f"{vpc_name}-NatGatewayIds",
-                value=",".join(nat_gateway_ids),
-                description=f"NAT Gateway IDs for {vpc_name}",
-                export_name=f"{self.deployment.workload_name}-{self.deployment.environment}-nat-gateway-ids",
-            )
+        return
+       
 
     def _export_ssm_parameters(self) -> None:
         """Export SSM parameters using standardized approach"""
@@ -399,7 +296,7 @@ class VpcStack(IStack, StandardizedSsmMixin):
             resource_values["internet_gateway_id"] = self.vpc.internet_gateway_id
 
         # Export using standardized SSM mixin
-        exported_params = self.export_standardized_ssm_parameters(resource_values)
+        exported_params = self.export_ssm_parameters(resource_values)
         
         logger.info(f"Exported SSM parameters: {exported_params}")
 
@@ -431,7 +328,7 @@ class VpcStack(IStack, StandardizedSsmMixin):
     # Backward compatibility methods
     def auto_export_resources(self, resource_values: Dict[str, Any], context: Dict[str, Any] = None) -> Dict[str, str]:
         """Backward compatibility method for existing modules."""
-        return self.export_standardized_ssm_parameters(resource_values)
+        return self.export_ssm_parameters(resource_values)
 
     def auto_import_resources(self, context: Dict[str, Any] = None) -> Dict[str, Any]:
         """Backward compatibility method for existing modules."""

cdk_factory/stack_library/websites/static_website_stack.py

@@ -113,12 +113,16 @@ class StaticWebSiteStack(IStack):
         self, stack_config: StackConfig, workload: WorkloadConfig
     ) -> str:
         source = stack_config.dictionary.get("src", {}).get("path")
+        if not source:
+            raise ValueError("Source path is required for static website stack")
         for base in workload.paths:
-            candidate = Path(os.path.join(Path(base), source)).resolve()
+            if base is None:
+                continue
+            candidate = Path(os.path.join(str(Path(base)), source)).resolve()
 
             if candidate.exists():
                 return str(candidate)
-        raise ValueError(f"Could not find the source path: {source}")
+        raise ValueError(f"Could not find the source path for static site: {source}")
 
     def __setup_cloudfront_distribution(
         self,
@@ -225,7 +229,7 @@ class StaticWebSiteStack(IStack):
             bucket: The S3 bucket
             cloudfront_distribution: The CloudFront distribution construct
         """
-        ssm_exports = stack_config.dictionary.get("ssm_exports", {})
+        ssm_exports = stack_config.dictionary.get("ssm", {}).get("exports", {})
         
         if not ssm_exports:
             logger.debug("No SSM exports configured for this stack")

cdk_factory/utilities/api_gateway_integration_utility.py

@@ -555,7 +555,7 @@ class ApiGatewayIntegrationUtility:
                             api_gateway_config["ssm"]["imports"] = {}
                         api_gateway_config["ssm"]["imports"]["user_pool_arn"] = "/{{ORGANIZATION}}/{{ENVIRONMENT}}/cognito/user-pool/arn"
                     
-                    ssm_mixin.setup_standardized_ssm_integration(
+                    ssm_mixin.setup_ssm_integration(
                         scope=self.scope,
                         config=api_gateway_config,
                         resource_type="cognito",
@@ -882,7 +882,7 @@ class ApiGatewayIntegrationUtility:
 
                 # Setup enhanced SSM integration for auto-import
                 # Use consistent resource name for cross-stack compatibility
-                ssm_mixin.setup_standardized_ssm_integration(
+                ssm_mixin.setup_ssm_integration(
                     scope=self.scope,
                     config=api_gateway_config,
                     resource_type="api-gateway",

cdk_factory/utilities/environment_services.py

@@ -173,9 +173,9 @@ class EnvironmentServices:
             environment = {}
         # more verbose
         environment["WORKLOAD_NAME"] = deployment.workload.get("name", "NA")
-        environment["ENVIRONMENT_NAME"] = deployment.environment
+        environment["ENVIRONMENT_NAME"] = deployment.workload.get("environment", deployment.environment)
         environment["DEPLOYMENT_NAME"] = deployment.name
-        environment["ENVIRONMENT"] = deployment.environment
+        environment["ENVIRONMENT"] = deployment.workload.get("environment", deployment.environment)
         environment["PIPELINE"] = deployment.pipeline.get("name", "NA")
         environment["ACCOUNT"] = deployment.account
         environment["DEPLOYMENT"] = deployment.name

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.17.6"
+__version__ = "0.20.0"