cdk-factory 0.18.21__py3-none-any.whl → 0.19.13__py3-none-any.whl

cdk_factory/configurations/resources/lambda_edge.py

@@ -49,16 +49,30 @@ class LambdaEdgeConfig(EnhancedBaseConfig):
 
     @property
     def timeout(self) -> int:
-        """Timeout in seconds (max 5 for origin-request)"""
+        """Timeout in seconds
+        viewer-request: 5s
+        viewer-response: 5s
+        ---
+        origin-request: 30s
+        origin-response: 30s
+        
+        
+        """
         timeout = int(self._config.get("timeout", 5))
-        if timeout > 5:
-            raise ValueError("Lambda@Edge origin-request timeout cannot exceed 5 seconds")
+
+        event_type = self.event_type
+        if event_type == "viewer-request" or event_type == "viewer-response":
+            if timeout > 5:
+                raise ValueError("Lambda@Edge viewer timeout cannot exceed 5 seconds. Value was set to {}".format(timeout))
+        else:
+            if timeout > 30:
+                raise ValueError("Lambda@Edge origin timeout cannot exceed 30 seconds. Value was set to {}".format(timeout))
         return timeout
 
     @property
     def code_path(self) -> str:
         """Path to Lambda function code directory"""
-        return self._config.get("code_path", "./lambdas/edge/ip_gate")
+        return self._config.get("code_path", "./lambdas/cloudfront/ip_gate")
 
     @property
     def environment(self) -> Dict[str, str]:

cdk_factory/configurations/resources/rds.py

@@ -29,7 +29,7 @@ class RdsConfig(EnhancedBaseConfig):
     @property
     def name(self) -> str:
         """RDS instance name"""
-        return self.__config.get("name", "database")
+        return self.__config.get("name", self.database_name)
     
     @property
     def identifier(self) -> str:

cdk_factory/configurations/resources/s3.py

@@ -158,7 +158,15 @@ class S3BucketConfig(EnhancedBaseConfig):
             value = self.__config.get("block_public_access")
 
         if value and isinstance(value, str):
-            if value.lower() == "block_acls":
+            if value.lower() == "disabled":
+                # For public website hosting, disable block public access
+                return s3.BlockPublicAccess(
+                    block_public_acls=False,
+                    block_public_policy=False,
+                    ignore_public_acls=False,
+                    restrict_public_buckets=False
+                )
+            elif value.lower() == "block_acls":
                 return s3.BlockPublicAccess.BLOCK_ACLS
             # elif value.lower() == "block_public_acls":
             #     return s3.BlockPublicAccess.block_public_acls

cdk_factory/constructs/cloudfront/cloudfront_distribution_construct.py

@@ -558,7 +558,7 @@ class CloudFrontDistributionConstruct(Construct):
         """
         bucket_policy = s3.BucketPolicy(
             self,
-            id=f"CloudFrontBucketPolicy-{self.source_bucket.bucket_name}",
+            id="CloudFrontBucketPolicy",
             bucket=self.source_bucket,
         )
 

cdk_factory/stack_library/acm/acm_stack.py

@@ -25,6 +25,7 @@ logger = Logger(service="AcmStack")
 
 @register_stack("acm_stack")
 @register_stack("certificate_stack")
+@register_stack("certificate_library_module")
 class AcmStack(IStack, StandardizedSsmMixin):
     """
     Reusable stack for AWS Certificate Manager.
@@ -152,18 +153,7 @@ class AcmStack(IStack, StandardizedSsmMixin):
 
     def _add_outputs(self, cert_name: str) -> None:
         """Add CloudFormation outputs"""
-        cdk.CfnOutput(
-            self,
-            "CertificateArn",
-            value=self.certificate.certificate_arn,
-            description=f"Certificate ARN for {self.acm_config.domain_name}",
-            export_name=f"{cert_name}-arn",
-        )
-        
-        cdk.CfnOutput(
-            self,
-            "DomainName",
-            value=self.acm_config.domain_name,
-            description="Primary domain name for the certificate",
-            export_name=f"{cert_name}-domain",
-        )
+
+        return
+
+       

cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py

@@ -13,7 +13,7 @@ from aws_cdk import aws_cloudwatch as cloudwatch
 from aws_cdk import aws_iam as iam
 from aws_cdk import aws_ssm as ssm
 from aws_cdk import aws_ecs as ecs
-from aws_cdk import Duration, Stack
+from aws_cdk import Duration, Stack, CfnUpdatePolicy
 from aws_lambda_powertools import Logger
 from constructs import Construct
 
@@ -539,43 +539,62 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         
         if not instance_refresh_config.get("enabled", False):
             return
+
+        logger.warning("Instance refresh is not supported in this version of the CDK")
+        return
             
         # Get the CloudFormation ASG resource
         cfn_asg = asg.node.default_child
         
-        # Configure instance refresh properties
-        refresh_props = {}
+        # Configure instance refresh using CloudFormation UpdatePolicy
+        # UpdatePolicy is added at the resource level, not as a property
+        update_policy = {
+            "AutoScalingRollingUpdate": {
+                "PauseTime": "PT300S",  # 5 minutes pause
+                "MinInstancesInService": "1",
+                "MaxBatchSize": "1",
+                "WaitOnResourceSignals": True,
+                "SuspendProcesses": [
+                    "HealthCheck",
+                    "ReplaceUnhealthy",
+                    "AZRebalance",
+                    "AlarmNotification",
+                    "ScheduledActions"
+                ]
+            }
+        }
         
-        if "min_healthy_percentage" in instance_refresh_config:
-            refresh_props["min_healthy_percentage"] = instance_refresh_config["min_healthy_percentage"]
-            
-        if "instance_warmup" in instance_refresh_config:
-            refresh_props["instance_warmup"] = instance_refresh_config["instance_warmup"]
-            
-        if "preferences" in instance_refresh_config:
-            preferences = instance_refresh_config["preferences"]
-            
-            # Build preferences property
-            pref_props = {}
-            
-            if "skip_matching" in preferences:
-                pref_props["skip_matching"] = preferences["skip_matching"]
-                
-            if "auto_rollback" in preferences:
-                pref_props["auto_rollback"] = preferences["auto_rollback"]
-                
-            if "instance_warmup" in preferences:
-                pref_props["instance_warmup"] = preferences["instance_warmup"]
-                
-            if "min_healthy_percentage" in preferences:
-                pref_props["min_healthy_percentage"] = preferences["min_healthy_percentage"]
-                
-            if pref_props:
-                refresh_props["preferences"] = pref_props
+        # # Apply instance refresh using CloudFormation's cfn_options.update_policy
+        # cfn_asg.cfn_options.update_policy = cdk.CfnUpdatePolicy.from_rolling_update(
+        #     pause_time=cdk.Duration.seconds(300),
+        #     min_instances_in_service=1,
+        #     max_batch_size=1,
+        #     wait_on_resource_signals=True
+        # )
+        
+        # Grab the L1 to attach UpdatePolicy.InstanceRefresh
+        cfn_asg: autoscaling.CfnAutoScalingGroup = asg.node.default_child
+
+        # cfn_asg.cfn_options.update_policy = CfnUpdatePolicy.from_auto_scaling_instance_refresh(
+        #     # Triggers tell CFN *what* changes should start a refresh
+        #     triggers=[CfnUpdatePolicy.InstanceRefreshTrigger.LAUNCH_TEMPLATE],
+        #     preferences=CfnUpdatePolicy.InstanceRefreshPreferences(
+        #         # warmup is like “grace” before counting a new instance healthy
+        #         instance_warmup=Duration.minutes(5),
+        #         # how aggressive the refresh is; 90 keeps capacity high
+        #         min_healthy_percentage=90,
+        #         # skip instances that already match the new LT (fast when only userdata/env tweaked)
+        #         skip_matching=True,
+        #         # optional: put instances in Standby first; default is rolling terminate/launch
+        #         # standby_instances=CfnUpdatePolicy.StandbyInstances.TERMINATE,
+        #         # checkpoint_percentages=[25, 50, 75],   # optional: progressive checkpoints
+        #         # checkpoint_delay=Duration.minutes(2),  # optional delay at checkpoints
+        #     ),
+        # )
+        logger.info(f"Configured instance refresh via CDK CfnUpdatePolicy")
         
-        if refresh_props:
-            cfn_asg.add_property_override("InstanceRefresh", refresh_props)
-            logger.info(f"Configured instance refresh: {refresh_props}")
+        # Note: This provides rolling update functionality similar to instance refresh
+        # For true instance refresh with preferences, we would need CDK v2.80+ or custom CloudFormation
 
 
 # Backward compatibility alias

cdk_factory/stack_library/cloudfront/cloudfront_stack.py

@@ -14,6 +14,7 @@ from aws_cdk import (
     aws_cloudfront_origins as origins,
     aws_certificatemanager as acm,
     aws_route53 as route53,
+    aws_s3 as s3,
     aws_lambda as _lambda,
     aws_ssm as ssm,
     CfnOutput,
@@ -144,7 +145,7 @@ class CloudFrontStack(IStack):
             return
 
         # Check if certificate ARN is provided
-        cert_arn = cert_config.get("arn")
+        cert_arn = self.resolve_ssm_value(self, cert_config.get("arn"), "CertificateARN")
         if cert_arn:
             self.certificate = acm.Certificate.from_certificate_arn(
                 self, "Certificate", certificate_arn=cert_arn
@@ -172,14 +173,14 @@ class CloudFrontStack(IStack):
                     "CloudFront certificates must be created in us-east-1"
                 )
                 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",
@@ -222,27 +223,29 @@ class CloudFrontStack(IStack):
 
     def _create_custom_origin(self, config: Dict[str, Any]) -> cloudfront.IOrigin:
         """Create custom origin (ALB, API Gateway, etc.)"""
-        domain_name = config.get("domain_name")
+        domain_name = self.resolve_ssm_value(
+            self, config.get("domain_name"), config.get("domain_name")
+        )
         origin_id = config.get("id")
 
         if not domain_name:
             raise ValueError("domain_name is required for custom origin")
 
-        # Check if domain name is a placeholder from ssm_imports
-        if domain_name.startswith("{{") and domain_name.endswith("}}"):
-            placeholder_key = domain_name[2:-2]  # Remove {{ and }}
-            if placeholder_key in self.ssm_imported_values:
-                domain_name = self.ssm_imported_values[placeholder_key]
-                logger.info(f"Resolved domain from SSM import: {placeholder_key}")
-            else:
-                logger.warning(f"Placeholder {domain_name} not found in SSM imports")
-
-        # Legacy support: Check if domain name is an SSM parameter reference
-        elif domain_name.startswith("{{ssm:") and domain_name.endswith("}}"):
-            # Extract SSM parameter name
-            ssm_param = domain_name[6:-2]  # Remove {{ssm: and }}
-            domain_name = ssm.StringParameter.value_from_lookup(self, ssm_param)
-            logger.info(f"Resolved domain from SSM lookup {ssm_param}: {domain_name}")
+        # # Check if domain name is a placeholder from ssm_imports
+        # if domain_name.startswith("{{") and domain_name.endswith("}}"):
+        #     placeholder_key = domain_name[2:-2]  # Remove {{ and }}
+        #     if placeholder_key in self.ssm_imported_values:
+        #         domain_name = self.ssm_imported_values[placeholder_key]
+        #         logger.info(f"Resolved domain from SSM import: {placeholder_key}")
+        #     else:
+        #         logger.warning(f"Placeholder {domain_name} not found in SSM imports")
+
+        # # Legacy support: Check if domain name is an SSM parameter reference
+        # elif domain_name.startswith("{{ssm:") and domain_name.endswith("}}"):
+        #     # Extract SSM parameter name
+        #     ssm_param = domain_name[6:-2]  # Remove {{ssm: and }}
+        #     domain_name = ssm.StringParameter.value_from_lookup(self, ssm_param)
+        #     logger.info(f"Resolved domain from SSM lookup {ssm_param}: {domain_name}")
 
         # Build custom headers (e.g., X-Origin-Secret)
         custom_headers = {}
@@ -296,12 +299,34 @@ class CloudFrontStack(IStack):
 
     def _create_s3_origin(self, config: Dict[str, Any]) -> cloudfront.IOrigin:
         """Create S3 origin"""
-        # S3 origin implementation
-        # This would use origins.S3Origin
-        raise NotImplementedError(
-            "S3 origin support - use existing static_website_stack for S3"
+        bucket_name = self.resolve_ssm_value(
+            self, config.get("bucket_name"), config.get("bucket_name")
         )
 
+        origin_path = config.get("origin_path", "")
+
+        if not bucket_name:
+            raise ValueError("S3 origin requires 'bucket_name' configuration")
+
+        # For S3 origins, we need to import the bucket by name
+        bucket = s3.Bucket.from_bucket_name(
+            self,
+            id=f"S3OriginBucket-{config.get('id', 'unknown')}",
+            bucket_name=bucket_name,
+        )
+
+        # Create S3 origin with OAC (Origin Access Control) for security
+        origin = origins.S3BucketOrigin.with_origin_access_control(
+            bucket,
+            origin_path=origin_path,
+            origin_access_levels=[
+                cloudfront.AccessLevel.READ,
+                cloudfront.AccessLevel.LIST,
+            ],
+        )
+
+        return origin
+
     def _create_distribution(self) -> None:
         """Create CloudFront distribution"""
 

cdk_factory/stack_library/code_artifact/code_artifact_stack.py

@@ -140,32 +140,10 @@ class CodeArtifactStack(IStack, StandardizedSsmMixin):
 
     def _add_outputs(self) -> None:
         """Add CloudFormation outputs for the CodeArtifact resources"""
+
+        
         # Domain outputs
         if self.domain:
             domain_name = self.code_artifact_config.domain_name
             
-            # Domain ARN
-            cdk.CfnOutput(
-                self,
-                f"{domain_name}-domain-arn",
-                value=self.domain.attr_arn,
-                export_name=f"{self.deployment.build_resource_name(domain_name)}-domain-arn"
-            )
-            
-            # Domain URL
-            cdk.CfnOutput(
-                self,
-                f"{domain_name}-domain-url",
-                value=f"https://{self.code_artifact_config.account}.d.codeartifact.{self.code_artifact_config.region}.amazonaws.com/",
-                export_name=f"{self.deployment.build_resource_name(domain_name)}-domain-url"
-            )
-        
-        # Repository outputs
-        for repo_name, repo in self.repositories.items():
-            # Repository ARN
-            cdk.CfnOutput(
-                self,
-                f"{repo_name}-repo-arn",
-                value=repo.attr_arn,
-                export_name=f"{self.deployment.build_resource_name(repo_name)}-repo-arn"
-            )
+            

cdk_factory/stack_library/ecs/ecs_service_stack.py

@@ -101,6 +101,7 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         
         # Add outputs
         self._add_outputs(service_name)
+        self._export_to_ssm(service_name)
 
     def _load_vpc(self) -> None:
         """Load VPC using the centralized VPC provider mixin."""
@@ -225,6 +226,9 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
                     "CloudWatchAgentServerPolicy"
                 )
             )
+
+        # add any custom policies
+        self._add_custom_task_policies(task_role)
         
         # Create task definition based on launch type
         if self.ecs_config.launch_type == "EC2":
@@ -256,6 +260,37 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         # Add containers
         self._add_containers_to_task()
 
+    def _add_custom_task_policies(self, task_role: iam.Role) -> None:
+        """
+        Add custom task policies to the task definition.
+        """
+        for policy in self.ecs_config.task_definition.get("policies", []):
+
+            effect = policy.get("effect", "Allow")
+            action = policy.get("action", None)
+            actions = policy.get("actions", [])
+            if action:
+                actions.append(action)
+            resources = policy.get("resources", [])
+            resource = policy.get("resource", None)
+            if resource:
+                resources.append(resource)
+
+            if effect == "Allow" and actions:
+                effect = iam.Effect.ALLOW
+            if effect == "Deny" and actions:
+                effect = iam.Effect.DENY
+
+            sid = policy.get("sid", None)
+            task_role.add_to_policy(
+                iam.PolicyStatement(
+                    effect=effect,
+                    actions=actions,
+                    resources=resources,
+                    sid=sid,
+                )
+            )
+
     def _add_volumes_to_task(self) -> None:
         """
         Add volumes to the task definition.
@@ -603,35 +638,13 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
             scale_out_cooldown=cdk.Duration.seconds(60),
         )
 
+    
+
     def _add_outputs(self, service_name: str) -> None:
         """Add CloudFormation outputs"""
+        return
         
-        # Service name output
-        cdk.CfnOutput(
-            self,
-            "ServiceName",
-            value=self.service.service_name,
-            description=f"ECS Service Name: {service_name}",
-        )
-        
-        # Service ARN output
-        cdk.CfnOutput(
-            self,
-            "ServiceArn",
-            value=self.service.service_arn,
-            description=f"ECS Service ARN: {service_name}",
-        )
-        
-        # Cluster name output
-        cdk.CfnOutput(
-            self,
-            "ClusterName",
-            value=self.cluster.cluster_name,
-            description=f"ECS Cluster Name for {service_name}",
-        )
         
-        # Export to SSM if configured
-        self._export_to_ssm(service_name)
 
     def _export_to_ssm(self, service_name: str) -> None:
         """Export resource ARNs and names to SSM Parameter Store"""

cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py

@@ -53,6 +53,8 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
         self.workload: Optional[WorkloadConfig] = None
         self.function: Optional[_lambda.Function] = None
         self.function_version: Optional[_lambda.Version] = None
+        # Cache for resolved environment variables to prevent duplicate construct creation
+        self._resolved_env_cache: Optional[Dict[str, str]] = None
 
     def build(
         self,
@@ -98,15 +100,38 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
         # Create version (required for Lambda@Edge)
         self._create_function_version(function_name)
         
+        # Configure edge log retention for regional logs
+        self._configure_edge_log_retention(function_name)
+        
         # Add outputs
         self._add_outputs(function_name)
 
+    def _sanitize_construct_name(self, name: str) -> str:
+        """
+        Create a deterministic, valid CDK construct name from any string.
+        Replaces non-alphanumeric characters with dashes and limits length.
+        """
+        # Replace non-alphanumeric characters with dashes
+        sanitized = ''.join(c if c.isalnum() else '-' for c in name)
+        # Remove consecutive dashes
+        while '--' in sanitized:
+            sanitized = sanitized.replace('--', '-')
+        # Remove leading/trailing dashes
+        sanitized = sanitized.strip('-')
+        # Limit to 255 characters (CDK limit)
+        return sanitized[:255]
+
     def _resolve_environment_variables(self) -> Dict[str, str]:
         """
         Resolve environment variables, including SSM parameter references.
         Supports {{ssm:parameter-path}} syntax for dynamic SSM lookups.
         Uses CDK tokens that resolve at deployment time, not synthesis time.
+        Caches results to prevent duplicate construct creation.
         """
+        # Return cached result if available
+        if self._resolved_env_cache is not None:
+            return self._resolved_env_cache
+        
         resolved_env = {}
         
         for key, value in self.edge_config.environment.items():
@@ -115,24 +140,29 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
                 # Extract SSM parameter path
                 ssm_param_path = value[6:-2]  # Remove {{ssm: and }}
                 
+                # Create deterministic construct name from parameter path
+                construct_name = self._sanitize_construct_name(f"env-{key}-{ssm_param_path}")
+                
                 # Import SSM parameter - this creates a token that resolves at deployment time
                 param = ssm.StringParameter.from_string_parameter_name(
                     self,
-                    f"env-{key}-{hash(ssm_param_path) % 10000}",
+                    construct_name,
                     ssm_param_path
                 )
                 resolved_value = param.string_value
-                logger.info(f"Resolved environment variable {key} from SSM {ssm_param_path}")
+                logger.info(f"Resolved environment variable {key} from SSM {ssm_param_path} as {construct_name}")
                 resolved_env[key] = resolved_value
             else:
                 resolved_env[key] = value
         
+        # Cache the result
+        self._resolved_env_cache = resolved_env
         return resolved_env
 
     def _create_lambda_function(self, function_name: str) -> None:
         """Create the Lambda function"""
         
-        # Resolve code path - support package references (e.g., "cdk_factory:lambdas/edge/ip_gate")
+        # Resolve code path - support package references (e.g., "cdk_factory:lambdas/cloudfront/ip_gate")
         code_path_str = self.edge_config.code_path
         
         if ':' in code_path_str:
@@ -185,10 +215,12 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
         # Create runtime configuration file for Lambda@Edge
         # Since Lambda@Edge doesn't support environment variables, we bundle a config file
         # Use the full function_name (e.g., "tech-talk-dev-ip-gate") not just the base name
+        resolved_env = self._resolve_environment_variables()
         runtime_config = {
             'environment': self.deployment.environment,
             'function_name': function_name,
-            'region': self.deployment.region
+            'region': self.deployment.region,
+            'environment_variables': resolved_env  # Add actual environment variables
         }
         
         runtime_config_path = temp_code_dir / 'runtime_config.json'
@@ -239,7 +271,8 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
             f"{function_name}-Role",
             assumed_by=iam.CompositePrincipal(
                 iam.ServicePrincipal("lambda.amazonaws.com"),
-                iam.ServicePrincipal("edgelambda.amazonaws.com")
+                iam.ServicePrincipal("edgelambda.amazonaws.com"),
+                iam.ServicePrincipal("cloudfront.amazonaws.com")  # Add CloudFront service principal
             ),
             description=f"Execution role for Lambda@Edge function {function_name}",
             managed_policies=[
@@ -285,6 +318,36 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
         for key, value in self.edge_config.tags.items():
             cdk.Tags.of(self.function).add(key, value)
 
+        # Add resource-based policy allowing CloudFront to invoke the Lambda function
+        # This is REQUIRED for Lambda@Edge to work properly
+        permission_kwargs = {
+            "principal": iam.ServicePrincipal("cloudfront.amazonaws.com"),
+            "action": "lambda:InvokeFunction",
+        }
+        
+        # Optional: Add source ARN restriction if CloudFront distribution ARN is available
+        # This provides more secure permission scoping
+        distribution_arn_path = f"/{self.deployment.environment}/{self.workload.name}/cloudfront/arn"
+        try:
+            distribution_arn = ssm.StringParameter.from_string_parameter_name(
+                self,
+                "cloudfront-distribution-arn",
+                distribution_arn_path
+            ).string_value
+            
+            # Add source ARN condition for more secure permission scoping
+            permission_kwargs["source_arn"] = distribution_arn
+            logger.info(f"Adding CloudFront permission with source ARN restriction: {distribution_arn}")
+        except Exception:
+            # Distribution ARN not available (common during initial deployment)
+            # CloudFront will scope the permission appropriately when it associates the Lambda
+            logger.warning(f"CloudFront distribution ARN not found at {distribution_arn_path}, using open permission")
+        
+        self.function.add_permission(
+            "CloudFrontInvokePermission",
+            **permission_kwargs
+        )
+
     def _create_function_version(self, function_name: str) -> None:
         """
         Create a version of the Lambda function.
@@ -300,33 +363,61 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
                 f"Version for Lambda@Edge deployment - {self.edge_config.description}"
             )
 
+    def _configure_edge_log_retention(self, function_name: str) -> None:
+        """
+        Configure log retention for Lambda@Edge regional logs.
+        
+        Lambda@Edge creates log groups in multiple regions that need
+        separate retention configuration from the primary log group.
+        """
+        from aws_cdk import custom_resources as cr
+        
+        # Get edge log retention from config (default to same as primary logs)
+        edge_retention_days = self.edge_config.dictionary.get("edge_log_retention_days", 7)
+        
+        # List of common Lambda@Edge regions
+        edge_regions = [
+            'us-east-1', 'us-east-2', 'us-west-1', 'us-west-2',
+            'eu-west-1', 'eu-west-2', 'eu-central-1',
+            'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1',
+            'ca-central-1', 'sa-east-1'
+        ]
+        
+        # Create custom resource to set log retention for each region
+        for region in edge_regions:
+            log_group_name = f"/aws/lambda/{region}.{function_name}"
+            
+            # Use AwsCustomResource to set log retention
+            cr.AwsCustomResource(
+                self, f"EdgeLogRetention-{region}",
+                on_update={
+                    "service": "Logs",
+                    "action": "putRetentionPolicy",
+                    "parameters": {
+                        "logGroupName": log_group_name,
+                        "retentionInDays": edge_retention_days
+                    },
+                    "physical_resource_id": cr.PhysicalResourceId.from_response("logGroupName")
+                },
+                on_delete={
+                    "service": "Logs", 
+                    "action": "deleteRetentionPolicy",
+                    "parameters": {
+                        "logGroupName": log_group_name
+                    },
+                    "physical_resource_id": cr.PhysicalResourceId.from_response("logGroupName")
+                },
+                policy=cr.AwsCustomResourcePolicy.from_sdk_calls(
+                    resources=[f"arn:aws:logs:{region}:*:log-group:{log_group_name}*"]
+                )
+            )
+        
+        logger.info(f"Configured edge log retention to {edge_retention_days} days for {len(edge_regions)} regions")
+
     def _add_outputs(self, function_name: str) -> None:
         """Add CloudFormation outputs and SSM exports"""
         
-        # CloudFormation outputs
-        cdk.CfnOutput(
-            self,
-            "FunctionName",
-            value=self.function.function_name,
-            description="Lambda function name",
-            export_name=f"{function_name}-name"
-        )
-        
-        cdk.CfnOutput(
-            self,
-            "FunctionArn",
-            value=self.function.function_arn,
-            description="Lambda function ARN (unversioned)",
-            export_name=f"{function_name}-arn"
-        )
         
-        cdk.CfnOutput(
-            self,
-            "FunctionVersionArn",
-            value=self.function_version.function_arn,
-            description="Lambda function version ARN (use this for Lambda@Edge)",
-            export_name=f"{function_name}-version-arn"
-        )
         
         # SSM Parameter Store exports (if configured)
         ssm_exports = self.edge_config.dictionary.get("ssm", {}).get("exports", {})

cdk_factory/stack_library/load_balancer/load_balancer_stack.py

@@ -656,36 +656,7 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
     def _export_cfn_outputs(self, lb_name: str) -> None:
         """Add CloudFormation outputs for the Load Balancer"""
-        if self.load_balancer:
-            # Load Balancer DNS Name
-            cdk.CfnOutput(
-                self,
-                f"{lb_name}-dns-name",
-                value=self.load_balancer.load_balancer_dns_name,
-                export_name=f"{self.deployment.build_resource_name(lb_name)}-dns-name",
-            )
-
-            # Load Balancer ARN
-            cdk.CfnOutput(
-                self,
-                f"{lb_name}-arn",
-                value=self.load_balancer.load_balancer_arn,
-                export_name=f"{self.deployment.build_resource_name(lb_name)}-arn",
-            )
-
-            # Target Group ARNs
-            for tg_name, target_group in self.target_groups.items():
-                # Normalize target group name for consistent CloudFormation export naming
-                normalized_tg_name = self.normalize_resource_name(
-                    tg_name, for_export=True
-                )
-                cdk.CfnOutput(
-                    self,
-                    f"{lb_name}-{normalized_tg_name}-arn",
-                    value=target_group.target_group_arn,
-                    export_name=f"{self.deployment.build_resource_name(lb_name)}-{normalized_tg_name}-arn",
-                )
-
+        return
     def _export_ssm_parameters(self, lb_name: str) -> None:
         """Export Load Balancer resources to SSM Parameter Store if configured"""
         if not self.load_balancer:
@@ -716,32 +687,4 @@ class LoadBalancerStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
     def _export_cfn_outputs(self, lb_name: str) -> None:
         """Add CloudFormation outputs for the Load Balancer"""
-        if self.load_balancer:
-            # Load Balancer DNS Name
-            cdk.CfnOutput(
-                self,
-                f"{lb_name}-dns-name",
-                value=self.load_balancer.load_balancer_dns_name,
-                export_name=f"{self.deployment.build_resource_name(lb_name)}-dns-name",
-            )
-
-            # Load Balancer ARN
-            cdk.CfnOutput(
-                self,
-                f"{lb_name}-arn",
-                value=self.load_balancer.load_balancer_arn,
-                export_name=f"{self.deployment.build_resource_name(lb_name)}-arn",
-            )
-
-            # Target Group ARNs
-            for tg_name, target_group in self.target_groups.items():
-                # Normalize target group name for consistent CloudFormation export naming
-                normalized_tg_name = self.normalize_resource_name(
-                    tg_name, for_export=True
-                )
-                cdk.CfnOutput(
-                    self,
-                    f"{lb_name}-{normalized_tg_name}-arn",
-                    value=target_group.target_group_arn,
-                    export_name=f"{self.deployment.build_resource_name(lb_name)}-{normalized_tg_name}-arn",
-                )
+        return

cdk_factory/stack_library/rds/rds_stack.py

@@ -285,31 +285,7 @@ class RdsStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
 
     def _add_outputs(self, db_name: str) -> None:
         """Add CloudFormation outputs for the RDS instance"""
-        if self.db_instance:
-            # Database endpoint
-            cdk.CfnOutput(
-                self,
-                f"{db_name}-endpoint",
-                value=self.db_instance.db_instance_endpoint_address,
-                export_name=f"{self.deployment.build_resource_name(db_name)}-endpoint",
-            )
-
-            # Database port
-            cdk.CfnOutput(
-                self,
-                f"{db_name}-port",
-                value=self.db_instance.db_instance_endpoint_port,
-                export_name=f"{self.deployment.build_resource_name(db_name)}-port",
-            )
-
-            # Secret ARN (if available)
-            if hasattr(self.db_instance, "secret") and self.db_instance.secret:
-                cdk.CfnOutput(
-                    self,
-                    f"{db_name}-secret-arn",
-                    value=self.db_instance.secret.secret_arn,
-                    export_name=f"{self.deployment.build_resource_name(db_name)}-secret-arn",
-                )
+        return
 
     def _export_ssm_parameters(self, db_name: str) -> None:
         """Export RDS connection info and credentials to SSM Parameter Store"""

cdk_factory/stack_library/route53/route53_stack.py

@@ -413,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/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/vpc/vpc_stack.py

@@ -241,115 +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
-        # Use workload environment for consistency
-        workload_env = self.workload.dictionary.get("environment", self.deployment.environment)
-        workload_name = self.workload.dictionary.get("name", self.deployment.workload_name)
-        
-        cdk.CfnOutput(
-            self,
-            f"{vpc_name}-VpcId",
-            value=self.vpc.vpc_id,
-            description=f"VPC ID for {vpc_name}",
-            export_name=f"{workload_name}-{workload_env}-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"{workload_name}-{workload_env}-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"{workload_name}-{workload_env}-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"{workload_name}-{workload_env}-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"{workload_name}-{workload_env}-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"{workload_name}-{workload_env}-nat-gateway-ids",
-            )
+        return
+       
 
     def _export_ssm_parameters(self) -> None:
         """Export SSM parameters using standardized approach"""

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,

cdk_factory/version.py

@@ -1 +1 @@
-__version__ = "0.18.21"
+__version__ = "0.19.13"

{cdk_factory-0.18.21.dist-info → cdk_factory-0.19.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.18.21
+Version: 0.19.13
 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.21.dist-info → cdk_factory-0.19.13.dist-info}/RECORD

@@ -2,7 +2,7 @@ cdk_factory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cdk_factory/app.py,sha256=RnX0-pwdTAPAdKJK_j13Zl8anf9zYKBwboR0KA8K8xM,10346
 cdk_factory/cdk.json,sha256=SKZKhJ2PBpFH78j-F8S3VDYW-lf76--Q2I3ON-ZIQfw,3106
 cdk_factory/cli.py,sha256=FGbCTS5dYCNsfp-etshzvFlGDCjC28r6rtzYbe7KoHI,6407
-cdk_factory/version.py,sha256=B2Sy7twJt6907f9y1FOcoO6wzQSV9i7I4wVmuy06Voc,24
+cdk_factory/version.py,sha256=qfLAZUWz8ZIxPUsFWlqQCfCwTNmUwrL2jNL4w6ZRFi0,24
 cdk_factory/builds/README.md,sha256=9BBWd7bXpyKdMU_g2UljhQwrC9i5O_Tvkb6oPvndoZk,90
 cdk_factory/commands/command_loader.py,sha256=QbLquuP_AdxtlxlDy-2IWCQ6D-7qa58aphnDPtp_uTs,3744
 cdk_factory/configurations/base_config.py,sha256=eJ3Pl3GWk1jVr_bYQaaWlw4_-ZiFGaiXllI_fOOX1i0,9323
@@ -34,25 +34,25 @@ cdk_factory/configurations/resources/ecr.py,sha256=iJEtKqBT7vQU0LU4urIglraIR7cPZ
 cdk_factory/configurations/resources/ecs_cluster.py,sha256=mQYJu7SUPDl5E4dMR6HCPFoWvFA3RGIb0iMNn-K7LX8,3635
 cdk_factory/configurations/resources/ecs_service.py,sha256=bOWjVECd6Kbc5NGGSnDaopnKrjRsUfmaZ6-qrsmTs3Q,6468
 cdk_factory/configurations/resources/exisiting.py,sha256=EVOLnkB-DGfTlmDgyQ5DD5k2zYfpFxqI3gugDR7mifI,478
-cdk_factory/configurations/resources/lambda_edge.py,sha256=MjmiwDkys4aoRvDQhH3MT6BgeShzJXNWL7761HJrLtQ,3404
+cdk_factory/configurations/resources/lambda_edge.py,sha256=C0S6HrQe2QPfmhj1PhZ7FEnT2EidOg5t-pUFUsOzaDc,3855
 cdk_factory/configurations/resources/lambda_function.py,sha256=VENZ9-ABJ5mjcN8J8wdLH4KHDYr1kWO0iFDH0B2mJXA,14659
 cdk_factory/configurations/resources/lambda_layers.py,sha256=gVeP_-LC3Eq0lkPaG_JfFUwboM5evRPr99SfKj53m7A,633
 cdk_factory/configurations/resources/lambda_triggers.py,sha256=MD7cdMNKEulNBhtMLIFnWJuJ5R-yyIqa0LHUgbSQerA,834
 cdk_factory/configurations/resources/load_balancer.py,sha256=P-jKemIjIWWqScmQKspmRy1m3BrwNkRtTNHDStOAJds,5617
 cdk_factory/configurations/resources/monitoring.py,sha256=CPYWbUbWQzoPqDhdPiB4Vahq-pPi6BEkavkVohadSIo,2422
-cdk_factory/configurations/resources/rds.py,sha256=ap2sbrcPsesfaPSluzyomGgT70_PUg9B39smVw6fvEM,15927
+cdk_factory/configurations/resources/rds.py,sha256=pX6uihguv1apYH93obcE4RloQDP48q5JHnYTnO39Pn0,15935
 cdk_factory/configurations/resources/resource_mapping.py,sha256=cwv3n63RJ6E59ErsmSTdkW4i-g8huhHtKI0ExbRhJxA,2182
 cdk_factory/configurations/resources/resource_naming.py,sha256=VE9S2cpzp11qqPL2z1sX79wXH0o1SntO2OG74nEmWC8,5508
 cdk_factory/configurations/resources/resource_types.py,sha256=1WQHyDoErb-M-tETZZzyLDtbq_jdC85-I403dM48pgE,2317
 cdk_factory/configurations/resources/route53.py,sha256=u63kw9cLBdOQrvxnULmopFqiArIYNvoWhrILNWvhD7w,3599
 cdk_factory/configurations/resources/route53_hosted_zone.py,sha256=qjEYPCSxSOx5blr9EULv892ezxkCs--yrLa1ngWbyXM,880
 cdk_factory/configurations/resources/rum.py,sha256=KgC2Mxhtr5XrICVXdgOXmxYp0GKu9lBs7izfG-Re9Ck,5294
-cdk_factory/configurations/resources/s3.py,sha256=kLY0XNCfErNYnOwekefFJxEJ_AKPifA-wSaaNczDp94,6036
+cdk_factory/configurations/resources/s3.py,sha256=3RVGvHLEnxa-hCgDXsqZ9nq8Aic0zW0JVgMdybl95is,6407
 cdk_factory/configurations/resources/security_group.py,sha256=8kQtaaRVEn2aDm8XoC7QFh2mDOFbPbgobmssIuqU8MA,2259
 cdk_factory/configurations/resources/security_group_full_stack.py,sha256=CujSl6mfPlVO0Dxso8fDjwW5VZB0vbeP9HqbcTaM8H4,2657
 cdk_factory/configurations/resources/sqs.py,sha256=fAh2dqttJ6PX46enFRULuiLEu3TEj0Vb2xntAOgUpYE,4346
 cdk_factory/configurations/resources/vpc.py,sha256=_W77du9wf8SJM64JbEAxEOQYerOm6aw4YaSsE7A_kKE,4453
-cdk_factory/constructs/cloudfront/cloudfront_distribution_construct.py,sha256=LHgjvTNghCMTpHh90VWl7AbE100Er-S9EgyEVt12J_c,25809
+cdk_factory/constructs/cloudfront/cloudfront_distribution_construct.py,sha256=WbbI37Ez262kffJNNpvyjXtFwOQlNfRql0NGBCLjpgE,25775
 cdk_factory/constructs/ecr/ecr_construct.py,sha256=jEimLwLvO5ERuFEn_L2q2pyPKgkdHQ6Oi7Sy990ttSg,11002
 cdk_factory/constructs/lambdas/lambda_function_construct.py,sha256=SQ5SEXn4kezVAzXuv_A_JB3o_svyBXOMi-htvfB9HQs,4516
 cdk_factory/constructs/lambdas/lambda_function_docker_construct.py,sha256=O8aiHpNQ59eE3qEttEHVxbvp06v4byXOeYCVTAOI_Cg,9993
@@ -83,42 +83,42 @@ cdk_factory/stack/stack_modules.py,sha256=kgEK-j0smZPozVwTCfM1g1V17EyTBT0TXAQZq4
 cdk_factory/stack_library/__init__.py,sha256=_v4kz9EYAjox6strrTK_4fb9GloJ2Kyhf63VRPivl2U,638
 cdk_factory/stack_library/stack_base.py,sha256=Cu3qeqPQf33QaaXoxk_EaziNCIXcyspOo5AU3eX_wyM,5140
 cdk_factory/stack_library/acm/__init__.py,sha256=4FNRLykblcKZvq_wieYwvv9N_jgrZnJ7ECH9xKh-0Ls,81
-cdk_factory/stack_library/acm/acm_stack.py,sha256=QJ3GkT17PmWoGkfO5Um02hvrfyJ9HbiPMnclwDP7IbA,5846
+cdk_factory/stack_library/acm/acm_stack.py,sha256=LW4QgzcMDvtSpqwfc4ykgpzDGvXe4udvWVE_DtBN4Zg,5414
 cdk_factory/stack_library/api_gateway/api_gateway_stack.py,sha256=PvLdGvcopGpLP0FwpfUcfXNiTIfYLTXqrG-TniE38yc,39643
 cdk_factory/stack_library/auto_scaling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=KfuNTKpDCQmvbw4F71sZBTkDFiBn1jkxxIojl21ExvQ,24140
+cdk_factory/stack_library/auto_scaling/auto_scaling_stack.py,sha256=G8OOgTAfsTDVArvuDfzuNpuGHzqz8kREHnnkMtjulAQ,25334
 cdk_factory/stack_library/aws_lambdas/lambda_stack.py,sha256=SFbBPvvCopbyiuYtq-O5sQkFCf94Wzua6aDUXiFDSB4,26161
 cdk_factory/stack_library/buckets/README.md,sha256=XkK3UNVtRLE7NtUvbhCOBBYUYi8hlrrSaI1s3GJVrqI,78
 cdk_factory/stack_library/buckets/bucket_stack.py,sha256=SLoZqSffAqmeBBEVUQg54D_8Ad5UKdkjEAmKAVgAqQo,1778
 cdk_factory/stack_library/cloudfront/__init__.py,sha256=Zfx50q4xIJ4ZEoVIzUBDTKbRE9DKDM6iyVIFhtQXvww,153
-cdk_factory/stack_library/cloudfront/cloudfront_stack.py,sha256=yuNs_W5b85JSXXv6_17OAD-e-wUitDPrRlZV4bxjChU,31459
-cdk_factory/stack_library/code_artifact/code_artifact_stack.py,sha256=k831b_fAFoXSiwj5cencnCQzUSeuKIUyVCp6Ev_TMgI,6274
+cdk_factory/stack_library/cloudfront/cloudfront_stack.py,sha256=7cYPqoQyiXH6r3j9jp9oLXv1ZDixeCYPAXJtTOmagPc,32309
+cdk_factory/stack_library/code_artifact/code_artifact_stack.py,sha256=o86cmC_ZV82z-K7DoAR0u1nAieoTi-vxRF01tyJn-9M,5297
 cdk_factory/stack_library/cognito/cognito_stack.py,sha256=3tjKCNcIwXZn7fd4EDQdY6H9m6CnZohI4uTQ4TpacRQ,25327
 cdk_factory/stack_library/dynamodb/dynamodb_stack.py,sha256=-_Ij1zXIxUuZIWgdevam_1vD3LEJ6pFs9U0hmw0KwIw,6743
 cdk_factory/stack_library/ecr/README.md,sha256=xw2wPx9WN03Y4BBwqvbi9lAFGNyaD1FUNpqxVJX14Oo,179
 cdk_factory/stack_library/ecr/ecr_stack.py,sha256=KLbd5WN5-ZiojsS5wJ4PX-tIL0cCylCSvXjO6sVrgWY,2102
 cdk_factory/stack_library/ecs/__init__.py,sha256=o5vGDtD_h-gVXb3-Ysr8xUNpEcMsnmMVgZv2Pupcdow,219
 cdk_factory/stack_library/ecs/ecs_cluster_stack.py,sha256=sAPTLU5CAwMoLTW_pNy_cd0OtVkfDR7IxxsSq5AE0yo,12091
-cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=EylXlAHTk0hx9IAl3VfW2hauE-J2jUnAFjsNMe73-ZM,27725
+cdk_factory/stack_library/ecs/ecs_service_stack.py,sha256=KB4YCIsMm5JIGM9Bm-bKcr3eX5xXFgnoA7jST_ekK44,28209
 cdk_factory/stack_library/lambda_edge/__init__.py,sha256=ByBJ_CWdc4UtTmFBZH-6pzBMNkjkdtE65AmnB0Fs6lM,156
-cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=C_h2Xb2_zaCGiw5otbeSozOLNbxaciMLo8FX_TQOAlw,16409
+cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py,sha256=eHh_k4mbNp1prEnNvKqfK82lLNrMZS-7HAaUYzFEoOU,21040
 cdk_factory/stack_library/load_balancer/__init__.py,sha256=wZpKw2OecLJGdF5mPayCYAEhu2H3c2gJFFIxwXftGDU,52
-cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=iiSxjuQOflF6_GLBS1xoK14fK2r47tpaI03EMvmE8V8,30693
+cdk_factory/stack_library/load_balancer/load_balancer_stack.py,sha256=ApW5q3SAvSJtiK0RInNljmubqXqKZU5QBAaUoeIW-pM,28287
 cdk_factory/stack_library/monitoring/__init__.py,sha256=k1G_KDx47Aw0UugaL99PN_TKlyLK4nkJVApCaAK7GJg,153
 cdk_factory/stack_library/monitoring/monitoring_stack.py,sha256=N_1YvEXE7fboH_S3kv_dSKZsufxMuPdFMjGzlNFpuSo,19283
 cdk_factory/stack_library/rds/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/rds/rds_stack.py,sha256=5dk_SUMkbnSalD2AKI0c-LrKbaHB4OOgq6DmRa4QMbM,15377
+cdk_factory/stack_library/rds/rds_stack.py,sha256=VToW-uFKAfilyhN4T8-TXaFW8f_VuXEIuUoBHvDN0Ns,14398
 cdk_factory/stack_library/route53/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/route53/route53_stack.py,sha256=4OeJxBTchcXHZznUQ6IIMuFmbsWtOoR0cIfDIIdHs8o,19624
+cdk_factory/stack_library/route53/route53_stack.py,sha256=taREOw-s7i1NZcdR-za1lKkj-Cj8UPmr4BO5txS18fI,18348
 cdk_factory/stack_library/rum/__init__.py,sha256=gUrWQdzd4rZ2J0YzAQC8PsEGAS7QgyYjB2ZCUKWasy4,90
 cdk_factory/stack_library/rum/rum_stack.py,sha256=c67m0Jbyx8hx9TTx9TBBhZMDqtSK7QCqKx_Ec1t8LgY,14067
 cdk_factory/stack_library/security_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cdk_factory/stack_library/security_group/security_group_full_stack.py,sha256=yvZ5QS9eDj_LkkwHY_Pcb37lOVPbGMfSdizZa1X6BEI,13561
-cdk_factory/stack_library/security_group/security_group_stack.py,sha256=Zv9FCEHvSBT1cM9bXOtyIUFwhRHKCSTgvaqOyhGj0wg,14456
-cdk_factory/stack_library/simple_queue_service/sqs_stack.py,sha256=jJksWrvrvgZUMM01RZ317DOIxqIJbkYYSYu38w0jHpc,6039
+cdk_factory/stack_library/security_group/security_group_full_stack.py,sha256=Y9JYD0QpKNe11fuCPjWlV1rucX1DMm7bs8Eu4t4XDqw,12204
+cdk_factory/stack_library/security_group/security_group_stack.py,sha256=uthk_MX2gNfA6a7gR7PjEfjov4WgTTtJ09G0cJOFWko,14168
+cdk_factory/stack_library/simple_queue_service/sqs_stack.py,sha256=HSJgWo4Wl6nQ5rJFQXOkDTyd_6PuHhx5VyaZLVvmYM8,4891
 cdk_factory/stack_library/vpc/__init__.py,sha256=7pIqP97Gf2AJbv9Ebp1WbQGHYhgEbWJ52L1MzeXBybA,42
-cdk_factory/stack_library/vpc/vpc_stack.py,sha256=AUq5oAJa1OrtUIqPZlnco0jSBOyOQvV3tEspIe2ZAGc,19451
-cdk_factory/stack_library/websites/static_website_stack.py,sha256=jnB-u6x37w2tsheG7WrKBY50WIx1AnCKoVh7mbT4rZU,11254
+cdk_factory/stack_library/vpc/vpc_stack.py,sha256=8uFyPIhAu-4A3iclTFlOiJrEZuYu67gI5UtiDSzmFF4,14461
+cdk_factory/stack_library/websites/static_website_stack.py,sha256=twpR9y4bxDx2GcEn0uP8PFNbsrgb8G9juZfeuHj7VqE,11433
 cdk_factory/stages/websites/static_website_stage.py,sha256=X4fpKXkhb0zIbSHx3QyddBhVSLBryb1vf1Cg2fMTqog,755
 cdk_factory/templates/README.md,sha256=ATBEjG6beYvbEAdLtZ_8xnxgFD5X0cgZoI_6pToqH90,2679
 cdk_factory/templates/app.py.template,sha256=aM60x0nNV80idtCL8jm1EddY63F5tDITYOlavg-BPMU,1069
@@ -136,8 +136,8 @@ cdk_factory/utilities/os_execute.py,sha256=5Op0LY_8Y-pUm04y1k8MTpNrmQvcLmQHPQITE
 cdk_factory/utils/api_gateway_utilities.py,sha256=If7Xu5s_UxmuV-kL3JkXxPLBdSVUKoLtohm0IUFoiV8,4378
 cdk_factory/validation/config_validator.py,sha256=Pb0TkLiPFzUplBOgMorhRCVm08vEzZhRU5xXCDTa5CA,17602
 cdk_factory/workload/workload_factory.py,sha256=yDI3cRhVI5ELNDcJPLpk9UY54Uind1xQoV3spzT4z7E,6068
-cdk_factory-0.18.21.dist-info/METADATA,sha256=cf8ZcJ_UApVTnZw3r8uwjqkYzfgTUxEkURAwg1KNX7g,2452
-cdk_factory-0.18.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cdk_factory-0.18.21.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
-cdk_factory-0.18.21.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
-cdk_factory-0.18.21.dist-info/RECORD,,
+cdk_factory-0.19.13.dist-info/METADATA,sha256=Rw6GGM7Hl5-md3ntKrGRfX2u1ppfZRfIextBHMW-FsE,2452
+cdk_factory-0.19.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cdk_factory-0.19.13.dist-info/entry_points.txt,sha256=S1DPe0ORcdiwEALMN_WIo3UQrW_g4YdQCLEsc_b0Swg,53
+cdk_factory-0.19.13.dist-info/licenses/LICENSE,sha256=NOtdOeLwg2il_XBJdXUPFPX8JlV4dqTdDGAd2-khxT8,1066
+cdk_factory-0.19.13.dist-info/RECORD,,