cdk-factory 0.18.16__tar.gz → 0.19.0__tar.gz

{cdk_factory-0.18.16 → cdk_factory-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdk_factory
-Version: 0.18.16
+Version: 0.19.0
 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.16 → cdk_factory-0.19.0}/pyproject.toml

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

{cdk_factory-0.18.16 → cdk_factory-0.19.0}/src/cdk_factory/configurations/resources/auto_scaling.py

@@ -74,6 +74,11 @@ class AutoScalingConfig(EnhancedBaseConfig):
         """Update policy configuration"""
         return self.__config.get("update_policy")
 
+    @property
+    def instance_refresh(self) -> Optional[Dict[str, Any]]:
+        """Instance refresh configuration for rolling updates"""
+        return self.__config.get("instance_refresh")
+
     @property
     def user_data_commands(self) -> List[str]:
         """User data commands to run on instance launch"""

{cdk_factory-0.18.16 → cdk_factory-0.19.0}/src/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-0.18.16 → cdk_factory-0.19.0}/src/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
 
@@ -241,11 +241,12 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         user_data = ec2.UserData.for_linux()
         
         # Add basic setup commands
-        user_data.add_commands(
-            "#!/bin/bash",
-            "yum update -y",
-            "yum install -y aws-cfn-bootstrap",
-        )
+        # this will break amazon linux 2023 which uses dnf instead of yum
+        # user_data.add_commands(
+        #     "#!/bin/bash",
+        #     "yum update -y",
+        #     "yum install -y aws-cfn-bootstrap",
+        # )
 
         # Add user data commands from configuration
         if self.asg_config.user_data_commands:
@@ -423,6 +424,10 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
             ],
         )
 
+        # Add instance refresh if configured
+        if self.asg_config.instance_refresh:
+            self._configure_instance_refresh(auto_scaling_group)
+
         # Attach target groups if configured
         self._attach_target_groups(auto_scaling_group)
 
@@ -528,6 +533,69 @@ class AutoScalingStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         
         logger.info(f"Exported SSM parameters: {exported_params}")
 
+    def _configure_instance_refresh(self, asg: autoscaling.AutoScalingGroup) -> None:
+        """Configure instance refresh for rolling updates"""
+        instance_refresh_config = self.asg_config.instance_refresh
+        
+        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 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"
+                ]
+            }
+        }
+        
+        # # 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")
+        
+        # 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
 AutoScalingStackStandardized = AutoScalingStack

{cdk_factory-0.18.16 → cdk_factory-0.19.0}/src/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-0.18.16 → cdk_factory-0.19.0}/src/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."""
@@ -540,6 +541,14 @@ class EcsServiceStack(IStack, VPCProviderMixin, StandardizedSsmMixin):
         """Attach service to load balancer target groups"""
         target_group_arns = self.ecs_config.target_group_arns
         
+        if target_group_arns:
+            tmp = []
+            for tg_arn in target_group_arns:
+                import hashlib
+                unique_id = hashlib.md5(tg_arn.encode()).hexdigest()
+                tmp.append(self.resolve_ssm_value(self, tg_arn, unique_id))
+            target_group_arns = tmp
+        
         if not target_group_arns:
             # Try to load from SSM if configured
             target_group_arns = self._load_target_groups_from_ssm()
@@ -595,35 +604,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-0.18.16 → cdk_factory-0.19.0}/src/cdk_factory/stack_library/lambda_edge/lambda_edge_stack.py

@@ -303,30 +303,7 @@ class LambdaEdgeStack(IStack, StandardizedSsmMixin):
     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-0.18.16 → cdk_factory-0.19.0}/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,
@@ -649,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:
@@ -709,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-0.18.16 → cdk_factory-0.19.0}/src/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-0.18.16 → cdk_factory-0.19.0}/src/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-0.18.16 → cdk_factory-0.19.0}/src/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-0.18.16 → cdk_factory-0.19.0}/src/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-0.18.16 → cdk_factory-0.19.0}/src/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