@fjall/components-infrastructure 0.77.4 → 0.78.5

package/dist/lib/patterns/aws/loadBalancer.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadBalancer = exports.LoadBalancerFactory = void 0;
+const constructs_1 = require("constructs");
+const aws_elasticloadbalancingv2_1 = require("aws-cdk-lib/aws-elasticloadbalancingv2");
+const aws_certificatemanager_1 = require("aws-cdk-lib/aws-certificatemanager");
+const aws_route53_1 = require("aws-cdk-lib/aws-route53");
+const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const cfnOutput_1 = require("../../resources/aws/utilities/cfnOutput");
+const hostedZone_1 = require("./hostedZone");
+/**
+ * Validates load balancer props and logs warnings for misconfigured options.
+ */
+function validateLoadBalancerProps(props) {
+    if (props.healthCheck) {
+        if (props.healthCheck.interval !== undefined) {
+            if (props.healthCheck.interval < 5 || props.healthCheck.interval > 300) {
+                throw new Error("Health check interval must be between 5 and 300 seconds.");
+            }
+        }
+        if (props.healthCheck.timeout !== undefined) {
+            if (props.healthCheck.timeout < 2 || props.healthCheck.timeout > 120) {
+                throw new Error("Health check timeout must be between 2 and 120 seconds.");
+            }
+        }
+    }
+}
+/**
+ * Factory for creating LoadBalancer constructs.
+ *
+ * @example
+ * // Simple HTTP load balancer
+ * const alb = app.addCompute(
+ *   LoadBalancerFactory.build("MainALB", {})
+ * );
+ *
+ * @example
+ * // HTTPS load balancer with domain
+ * const alb = app.addCompute(
+ *   LoadBalancerFactory.build("MainALB", {
+ *     domain: "app.example.com"
+ *   })
+ * );
+ *
+ * @example
+ * // Internal load balancer
+ * const alb = app.addCompute(
+ *   LoadBalancerFactory.build("InternalALB", {
+ *     public: false
+ *   })
+ * );
+ */
+class LoadBalancerFactory {
+    static build(id, props) {
+        return (app, scope) => {
+            validateLoadBalancerProps(props);
+            const resolvedProps = {
+                ...props,
+                vpc: props.vpc || app.getVpc()
+            };
+            return new LoadBalancer(scope, id, resolvedProps);
+        };
+    }
+}
+exports.LoadBalancerFactory = LoadBalancerFactory;
+/**
+ * Application Load Balancer construct that can be shared across multiple ECS services.
+ *
+ * Use LoadBalancerFactory.build() to create instances via app.addCompute().
+ */
+class LoadBalancer extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.defaultHealthCheck = props.healthCheck || {};
+        this.isHttps = !!props.domain;
+        // Create security group
+        this.securityGroup = new aws_ec2_1.SecurityGroup(this, "SecurityGroup", {
+            vpc: props.vpc,
+            description: `Security group for ${id} load balancer`,
+            allowAllOutbound: true
+        });
+        // Allow inbound traffic
+        const inboundPort = this.isHttps ? 443 : 80;
+        this.securityGroup.addIngressRule({ connections: { allowFromAnyIpv4: () => { } } }, aws_ec2_1.Port.tcp(inboundPort), `Allow inbound ${this.isHttps ? "HTTPS" : "HTTP"}`);
+        // Create ALB
+        const loadBalancerName = this.truncateName(`${id}ALB`, 32);
+        this.alb = new aws_elasticloadbalancingv2_1.ApplicationLoadBalancer(this, "ALB", {
+            vpc: props.vpc,
+            internetFacing: props.public !== false,
+            securityGroup: this.securityGroup,
+            loadBalancerName,
+            vpcSubnets: {
+                subnetType: props.public !== false ? aws_ec2_1.SubnetType.PUBLIC : aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS
+            }
+        });
+        // Set up domain if configured
+        if (props.domain) {
+            const domainConfig = this.normaliseDomainConfig(props.domain);
+            this.setupDomain(domainConfig);
+        }
+        // Create listener
+        if (this.isHttps && this.certificate) {
+            this.listener = this.alb.addListener("Listener", {
+                port: 443,
+                protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTPS,
+                certificates: [this.certificate]
+            });
+            // Add HTTP redirect
+            this.alb.addListener("HttpRedirect", {
+                port: 80,
+                protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP,
+                defaultAction: {
+                    redirect: {
+                        protocol: "HTTPS",
+                        port: "443",
+                        permanent: true
+                    }
+                }
+            });
+        }
+        else {
+            this.listener = this.alb.addListener("Listener", {
+                port: 80,
+                protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP
+            });
+        }
+        // Add default action (returns 503 if no targets match)
+        this.listener.addAction("DefaultAction", {
+            action: {
+                fixedResponse: {
+                    statusCode: 503,
+                    contentType: "text/plain",
+                    messageBody: "No service available"
+                }
+            }
+        });
+        // Set URL
+        this.url = this.isHttps
+            ? `https://${this.alb.loadBalancerDnsName}`
+            : `http://${this.alb.loadBalancerDnsName}`;
+        // Set up connections
+        this.connections = new aws_ec2_1.Connections({
+            securityGroups: [this.securityGroup],
+            defaultPort: aws_ec2_1.Port.tcp(inboundPort)
+        });
+        // Outputs
+        new cfnOutput_1.CfnOutput(this, "LoadBalancerDnsName", {
+            key: `${id}LoadBalancerDnsName`,
+            exportName: `${id}LoadBalancerDnsName`,
+            value: this.alb.loadBalancerDnsName
+        });
+        new cfnOutput_1.CfnOutput(this, "LoadBalancerUrl", {
+            key: `${id}LoadBalancerUrl`,
+            exportName: `${id}LoadBalancerUrl`,
+            value: this.url,
+            description: `Load Balancer URL for ${id}`
+        });
+        new cfnOutput_1.CfnOutput(this, "LoadBalancerArn", {
+            key: `${id}LoadBalancerArn`,
+            exportName: `${id}LoadBalancerArn`,
+            value: this.alb.loadBalancerArn,
+            description: `Load Balancer ARN for ${id}`
+        });
+    }
+    /**
+     * Register a target group with routing rules.
+     * Called internally by EcsCluster when loadBalancer.target is specified.
+     *
+     * @param targetGroup - The target group to register
+     * @param routing - Routing configuration (path, host, priority)
+     */
+    registerTargetGroup(targetGroup, routing) {
+        const conditions = [];
+        if (routing.path) {
+            const paths = Array.isArray(routing.path) ? routing.path : [routing.path];
+            conditions.push(aws_elasticloadbalancingv2_1.ListenerCondition.pathPatterns(paths));
+        }
+        if (routing.host) {
+            const hosts = Array.isArray(routing.host) ? routing.host : [routing.host];
+            conditions.push(aws_elasticloadbalancingv2_1.ListenerCondition.hostHeaders(hosts));
+        }
+        if (conditions.length === 0) {
+            throw new Error("At least one routing condition (path or host) must be specified.");
+        }
+        this.listener.addTargetGroups(`Rule${routing.priority}`, {
+            targetGroups: [targetGroup],
+            conditions,
+            priority: routing.priority
+        });
+    }
+    /**
+     * Create a target group for an ECS service.
+     * Returns the target group for the service to register with.
+     *
+     * @param id - Unique identifier for the target group
+     * @param port - Container port
+     * @param vpc - VPC for the target group
+     * @param healthCheckPath - Optional health check path override
+     */
+    createTargetGroup(id, port, vpc, healthCheckPath) {
+        const targetGroup = new aws_elasticloadbalancingv2_1.ApplicationTargetGroup(this, `${id}TargetGroup`, {
+            vpc,
+            port,
+            protocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTP,
+            targetType: aws_elasticloadbalancingv2_1.TargetType.IP,
+            healthCheck: {
+                path: healthCheckPath || this.defaultHealthCheck.path || "/",
+                interval: aws_cdk_lib_1.Duration.seconds(this.defaultHealthCheck.interval || 30),
+                timeout: aws_cdk_lib_1.Duration.seconds(this.defaultHealthCheck.timeout || 5),
+                healthyThresholdCount: this.defaultHealthCheck.healthyThreshold || 2,
+                unhealthyThresholdCount: this.defaultHealthCheck.unhealthyThreshold || 3
+            }
+        });
+        return targetGroup;
+    }
+    /**
+     * Allow traffic from this load balancer to a connectable resource.
+     */
+    allowTo(connectable, port) {
+        this.connections.allowTo(connectable, port || connectable.connections.defaultPort || aws_ec2_1.Port.allTcp());
+    }
+    normaliseDomainConfig(domain) {
+        if (typeof domain === "string") {
+            return { name: domain };
+        }
+        return domain;
+    }
+    setupDomain(config) {
+        // Get or create hosted zone
+        if (config.hostedZone) {
+            this.hostedZone = config.hostedZone.getInternalHostedZone();
+        }
+        else {
+            const hostedZone = new hostedZone_1.HostedZone(this, "HostedZone", {
+                zoneName: config.name
+            });
+            this.hostedZone = hostedZone.getInternalHostedZone();
+        }
+        // Get or create certificate
+        if (config.certificate) {
+            this.certificate = config.certificate;
+        }
+        else {
+            this.certificate = new aws_certificatemanager_1.Certificate(this, "Certificate", {
+                domainName: config.name,
+                validation: aws_certificatemanager_1.CertificateValidation.fromDns(this.hostedZone)
+            });
+        }
+        // Create DNS record pointing to ALB
+        new aws_route53_1.ARecord(this, "AliasRecord", {
+            zone: this.hostedZone,
+            recordName: config.name,
+            target: aws_route53_1.RecordTarget.fromAlias(new aws_route53_targets_1.LoadBalancerTarget(this.alb))
+        });
+    }
+    truncateName(name, maxLength) {
+        if (name.length <= maxLength) {
+            return name;
+        }
+        return name.substring(0, maxLength).replace(/-+$/, "");
+    }
+    /**
+     * Get the DNS name of the load balancer.
+     */
+    getDnsName() {
+        return this.alb.loadBalancerDnsName;
+    }
+    /**
+     * Get the ARN of the load balancer.
+     */
+    getArn() {
+        return this.alb.loadBalancerArn;
+    }
+}
+exports.LoadBalancer = LoadBalancer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loadBalancer.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/loadBalancer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport {\n  ApplicationLoadBalancer,\n  ApplicationListener,\n  ApplicationProtocol,\n  ApplicationTargetGroup,\n  ListenerCondition,\n  TargetType,\n  type IApplicationTargetGroup\n} from \"aws-cdk-lib/aws-elasticloadbalancingv2\";\nimport {\n  Certificate,\n  CertificateValidation\n} from \"aws-cdk-lib/aws-certificatemanager\";\nimport { ARecord, RecordTarget, type IHostedZone } from \"aws-cdk-lib/aws-route53\";\nimport { LoadBalancerTarget } from \"aws-cdk-lib/aws-route53-targets\";\nimport {\n  Connections,\n  type IConnectable,\n  type IVpc,\n  Port,\n  SecurityGroup,\n  SubnetType\n} from \"aws-cdk-lib/aws-ec2\";\nimport { Duration } from \"aws-cdk-lib\";\n\nimport type App from \"../../app\";\nimport { CfnOutput } from \"../../resources/aws/utilities/cfnOutput\";\nimport { HostedZone as FjallHostedZone } from \"./hostedZone\";\n\n/**\n * Routing configuration for registering services with the load balancer.\n */\nexport interface LoadBalancerRoutingConfig {\n  /**\n   * Path pattern(s) to match. Examples: \"/api/*\", [\"/api/*\", \"/v1/*\"]\n   */\n  path?: string | string[];\n  /**\n   * Host pattern(s) to match. Examples: \"api.example.com\", [\"api.example.com\", \"www.example.com\"]\n   */\n  host?: string | string[];\n  /**\n   * Priority for this routing rule. Lower numbers = higher priority.\n   * Must be unique per listener. Range: 1-50000.\n   */\n  priority: number;\n  /**\n   * Health check path for this target group. Default: \"/\"\n   */\n  healthCheckPath?: string;\n}\n\n/**\n * Health check configuration for the load balancer.\n */\nexport interface LoadBalancerHealthCheckConfig {\n  /** Health check path. Default: \"/\" */\n  path?: string;\n  /** Interval between health checks in seconds. Default: 30 */\n  interval?: number;\n  /** Health check timeout in seconds. Default: 5 */\n  timeout?: number;\n  /** Number of consecutive successes before healthy. Default: 2 */\n  healthyThreshold?: number;\n  /** Number of consecutive failures before unhealthy. Default: 3 */\n  unhealthyThreshold?: number;\n}\n\n/**\n * Domain configuration for HTTPS and DNS.\n */\nexport interface LoadBalancerDomainConfig {\n  /** Domain name (e.g., \"api.example.com\") */\n  name: string;\n  /** Existing hosted zone. If omitted, creates new one. */\n  hostedZone?: FjallHostedZone;\n  /** Existing certificate. If omitted, creates new one with DNS validation. */\n  certificate?: Certificate;\n}\n\n/**\n * Properties for LoadBalancerFactory.build()\n */\nexport interface ILoadBalancerProps {\n  /** VPC to place the load balancer in. Default: app's default VPC */\n  vpc?: IVpc;\n  /**\n   * Domain configuration for HTTPS.\n   * - string: Domain name (creates hosted zone and certificate)\n   * - LoadBalancerDomainConfig: Full configuration\n   * - Omit: HTTP only\n   */\n  domain?: string | LoadBalancerDomainConfig;\n  /**\n   * Whether the load balancer is internet-facing.\n   * Default: true\n   */\n  public?: boolean;\n  /**\n   * Default health check configuration.\n   * Individual services can override this.\n   */\n  healthCheck?: LoadBalancerHealthCheckConfig;\n}\n\n/**\n * Internal props with resolved VPC.\n */\ninterface LoadBalancerPropsResolved extends ILoadBalancerProps {\n  vpc: IVpc;\n}\n\n/**\n * Validates load balancer props and logs warnings for misconfigured options.\n */\nfunction validateLoadBalancerProps(props: ILoadBalancerProps): void {\n  if (props.healthCheck) {\n    if (props.healthCheck.interval !== undefined) {\n      if (props.healthCheck.interval < 5 || props.healthCheck.interval > 300) {\n        throw new Error(\n          \"Health check interval must be between 5 and 300 seconds.\"\n        );\n      }\n    }\n    if (props.healthCheck.timeout !== undefined) {\n      if (props.healthCheck.timeout < 2 || props.healthCheck.timeout > 120) {\n        throw new Error(\n          \"Health check timeout must be between 2 and 120 seconds.\"\n        );\n      }\n    }\n  }\n}\n\n/**\n * Factory for creating LoadBalancer constructs.\n *\n * @example\n * // Simple HTTP load balancer\n * const alb = app.addCompute(\n *   LoadBalancerFactory.build(\"MainALB\", {})\n * );\n *\n * @example\n * // HTTPS load balancer with domain\n * const alb = app.addCompute(\n *   LoadBalancerFactory.build(\"MainALB\", {\n *     domain: \"app.example.com\"\n *   })\n * );\n *\n * @example\n * // Internal load balancer\n * const alb = app.addCompute(\n *   LoadBalancerFactory.build(\"InternalALB\", {\n *     public: false\n *   })\n * );\n */\nexport class LoadBalancerFactory {\n  static build(id: string, props: ILoadBalancerProps) {\n    return (app: App, scope: Construct): LoadBalancer => {\n      validateLoadBalancerProps(props);\n\n      const resolvedProps: LoadBalancerPropsResolved = {\n        ...props,\n        vpc: props.vpc || app.getVpc()\n      };\n\n      return new LoadBalancer(scope, id, resolvedProps);\n    };\n  }\n}\n\n/**\n * Application Load Balancer construct that can be shared across multiple ECS services.\n *\n * Use LoadBalancerFactory.build() to create instances via app.addCompute().\n */\nexport class LoadBalancer extends Construct implements IConnectable {\n  public readonly alb: ApplicationLoadBalancer;\n  public readonly listener: ApplicationListener;\n  public readonly securityGroup: SecurityGroup;\n  public readonly url: string;\n  public readonly connections: Connections;\n\n  private readonly hostedZone?: IHostedZone;\n  private readonly certificate?: Certificate;\n  private readonly defaultHealthCheck: LoadBalancerHealthCheckConfig;\n  private readonly isHttps: boolean;\n\n  constructor(scope: Construct, id: string, props: LoadBalancerPropsResolved) {\n    super(scope, id);\n\n    this.defaultHealthCheck = props.healthCheck || {};\n    this.isHttps = !!props.domain;\n\n    // Create security group\n    this.securityGroup = new SecurityGroup(this, \"SecurityGroup\", {\n      vpc: props.vpc,\n      description: `Security group for ${id} load balancer`,\n      allowAllOutbound: true\n    });\n\n    // Allow inbound traffic\n    const inboundPort = this.isHttps ? 443 : 80;\n    this.securityGroup.addIngressRule(\n      { connections: { allowFromAnyIpv4: () => {} } } as any,\n      Port.tcp(inboundPort),\n      `Allow inbound ${this.isHttps ? \"HTTPS\" : \"HTTP\"}`\n    );\n\n    // Create ALB\n    const loadBalancerName = this.truncateName(`${id}ALB`, 32);\n    this.alb = new ApplicationLoadBalancer(this, \"ALB\", {\n      vpc: props.vpc,\n      internetFacing: props.public !== false,\n      securityGroup: this.securityGroup,\n      loadBalancerName,\n      vpcSubnets: {\n        subnetType:\n          props.public !== false ? SubnetType.PUBLIC : SubnetType.PRIVATE_WITH_EGRESS\n      }\n    });\n\n    // Set up domain if configured\n    if (props.domain) {\n      const domainConfig = this.normaliseDomainConfig(props.domain);\n      this.setupDomain(domainConfig);\n    }\n\n    // Create listener\n    if (this.isHttps && this.certificate) {\n      this.listener = this.alb.addListener(\"Listener\", {\n        port: 443,\n        protocol: ApplicationProtocol.HTTPS,\n        certificates: [this.certificate]\n      });\n\n      // Add HTTP redirect\n      this.alb.addListener(\"HttpRedirect\", {\n        port: 80,\n        protocol: ApplicationProtocol.HTTP,\n        defaultAction: {\n          redirect: {\n            protocol: \"HTTPS\",\n            port: \"443\",\n            permanent: true\n          }\n        } as any\n      });\n    } else {\n      this.listener = this.alb.addListener(\"Listener\", {\n        port: 80,\n        protocol: ApplicationProtocol.HTTP\n      });\n    }\n\n    // Add default action (returns 503 if no targets match)\n    this.listener.addAction(\"DefaultAction\", {\n      action: {\n        fixedResponse: {\n          statusCode: 503,\n          contentType: \"text/plain\",\n          messageBody: \"No service available\"\n        }\n      } as any\n    });\n\n    // Set URL\n    this.url = this.isHttps\n      ? `https://${this.alb.loadBalancerDnsName}`\n      : `http://${this.alb.loadBalancerDnsName}`;\n\n    // Set up connections\n    this.connections = new Connections({\n      securityGroups: [this.securityGroup],\n      defaultPort: Port.tcp(inboundPort)\n    });\n\n    // Outputs\n    new CfnOutput(this, \"LoadBalancerDnsName\", {\n      key: `${id}LoadBalancerDnsName`,\n      exportName: `${id}LoadBalancerDnsName`,\n      value: this.alb.loadBalancerDnsName\n    });\n\n    new CfnOutput(this, \"LoadBalancerUrl\", {\n      key: `${id}LoadBalancerUrl`,\n      exportName: `${id}LoadBalancerUrl`,\n      value: this.url,\n      description: `Load Balancer URL for ${id}`\n    });\n\n    new CfnOutput(this, \"LoadBalancerArn\", {\n      key: `${id}LoadBalancerArn`,\n      exportName: `${id}LoadBalancerArn`,\n      value: this.alb.loadBalancerArn,\n      description: `Load Balancer ARN for ${id}`\n    });\n  }\n\n  /**\n   * Register a target group with routing rules.\n   * Called internally by EcsCluster when loadBalancer.target is specified.\n   *\n   * @param targetGroup - The target group to register\n   * @param routing - Routing configuration (path, host, priority)\n   */\n  public registerTargetGroup(\n    targetGroup: IApplicationTargetGroup,\n    routing: LoadBalancerRoutingConfig\n  ): void {\n    const conditions: ListenerCondition[] = [];\n\n    if (routing.path) {\n      const paths = Array.isArray(routing.path) ? routing.path : [routing.path];\n      conditions.push(ListenerCondition.pathPatterns(paths));\n    }\n\n    if (routing.host) {\n      const hosts = Array.isArray(routing.host) ? routing.host : [routing.host];\n      conditions.push(ListenerCondition.hostHeaders(hosts));\n    }\n\n    if (conditions.length === 0) {\n      throw new Error(\n        \"At least one routing condition (path or host) must be specified.\"\n      );\n    }\n\n    this.listener.addTargetGroups(`Rule${routing.priority}`, {\n      targetGroups: [targetGroup],\n      conditions,\n      priority: routing.priority\n    });\n  }\n\n  /**\n   * Create a target group for an ECS service.\n   * Returns the target group for the service to register with.\n   *\n   * @param id - Unique identifier for the target group\n   * @param port - Container port\n   * @param vpc - VPC for the target group\n   * @param healthCheckPath - Optional health check path override\n   */\n  public createTargetGroup(\n    id: string,\n    port: number,\n    vpc: IVpc,\n    healthCheckPath?: string\n  ): ApplicationTargetGroup {\n    const targetGroup = new ApplicationTargetGroup(this, `${id}TargetGroup`, {\n      vpc,\n      port,\n      protocol: ApplicationProtocol.HTTP,\n      targetType: TargetType.IP,\n      healthCheck: {\n        path: healthCheckPath || this.defaultHealthCheck.path || \"/\",\n        interval: Duration.seconds(\n          this.defaultHealthCheck.interval || 30\n        ),\n        timeout: Duration.seconds(\n          this.defaultHealthCheck.timeout || 5\n        ),\n        healthyThresholdCount: this.defaultHealthCheck.healthyThreshold || 2,\n        unhealthyThresholdCount: this.defaultHealthCheck.unhealthyThreshold || 3\n      }\n    });\n\n    return targetGroup;\n  }\n\n  /**\n   * Allow traffic from this load balancer to a connectable resource.\n   */\n  public allowTo(connectable: IConnectable, port?: Port): void {\n    this.connections.allowTo(\n      connectable,\n      port || connectable.connections.defaultPort || Port.allTcp()\n    );\n  }\n\n  private normaliseDomainConfig(\n    domain: string | LoadBalancerDomainConfig\n  ): LoadBalancerDomainConfig {\n    if (typeof domain === \"string\") {\n      return { name: domain };\n    }\n    return domain;\n  }\n\n  private setupDomain(config: LoadBalancerDomainConfig): void {\n    // Get or create hosted zone\n    if (config.hostedZone) {\n      (this as any).hostedZone = config.hostedZone.getInternalHostedZone();\n    } else {\n      const hostedZone = new FjallHostedZone(this, \"HostedZone\", {\n        zoneName: config.name\n      });\n      (this as any).hostedZone = hostedZone.getInternalHostedZone();\n    }\n\n    // Get or create certificate\n    if (config.certificate) {\n      (this as any).certificate = config.certificate;\n    } else {\n      (this as any).certificate = new Certificate(this, \"Certificate\", {\n        domainName: config.name,\n        validation: CertificateValidation.fromDns(this.hostedZone)\n      });\n    }\n\n    // Create DNS record pointing to ALB\n    new ARecord(this, \"AliasRecord\", {\n      zone: this.hostedZone!,\n      recordName: config.name,\n      target: RecordTarget.fromAlias(new LoadBalancerTarget(this.alb))\n    });\n  }\n\n  private truncateName(name: string, maxLength: number): string {\n    if (name.length <= maxLength) {\n      return name;\n    }\n    return name.substring(0, maxLength).replace(/-+$/, \"\");\n  }\n\n  /**\n   * Get the DNS name of the load balancer.\n   */\n  public getDnsName(): string {\n    return this.alb.loadBalancerDnsName;\n  }\n\n  /**\n   * Get the ARN of the load balancer.\n   */\n  public getArn(): string {\n    return this.alb.loadBalancerArn;\n  }\n}\n"]}

package/dist/lib/patterns/aws/network.d.ts

@@ -53,6 +53,7 @@ export interface TransitGatewayConfig {
  * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }
  */
 export interface INetworkProps {
+    vpcName?: string;
     maxAzs?: number;
     cidrMask?: number;
     natGateways?: NatConfig | false;

package/dist/lib/patterns/aws/network.js

@@ -44,6 +44,7 @@ class Network extends constructs_1.Construct {
             ipv4IpamPoolId = aws_cdk_lib_1.Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);
         }
         const vpcProps = {
+            vpcName: props.vpcName,
             accountId,
             region,
             ipv4IpamPoolId,
@@ -96,4 +97,4 @@ class Network extends constructs_1.Construct {
     }
 }
 exports.Network = Network;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/network.ts"],"names":[],"mappings":";;;AAAA,2CAAuC;AACvC,6CAAiC;AAIjC,4DAAwE;AAsExE,SAAS,oBAAoB,CAAC,KAAoB;IAChD,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC;QACzE,OAAO,CAAC,IAAI,CACV,6DAA6D,KAAK,CAAC,MAAM,GAAG,CAC7E,CAAC;IACJ,CAAC;IAED,IACE,OAAO,KAAK,CAAC,WAAW,KAAK,QAAQ;QACrC,KAAK,CAAC,WAAW,KAAK,IAAI;QAC1B,KAAK,CAAC,WAAW,CAAC,KAAK,KAAK,SAAS,EACrC,CAAC;QACD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,CAAC,WAAW,CAAC,KAAK,GAAG,MAAM,EAAE,CAAC;YACrC,OAAO,CAAC,IAAI,CACV,yCAAyC,KAAK,CAAC,WAAW,CAAC,KAAK,qBAAqB,MAAM,IAAI,CAChG,CAAC;QACJ,CAAC;IACH,CAAC;IAED,IAAI,KAAK,CAAC,cAAc,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,EAAE,CAAC;QACrD,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;IAClE,CAAC;AACH,CAAC;AAED,MAAa,cAAc;IACzB,MAAM,CAAC,KAAK,CAAC,EAAU,EAAE,KAAoB;QAC3C,OAAO,CAAC,GAAQ,EAAE,KAAgB,EAAE,EAAE;YACpC,oBAAoB,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;QAC5C,CAAC,CAAC;IACJ,CAAC;CACF;AAPD,wCAOC;AAED,MAAa,OAAQ,SAAQ,sBAAS;IAGpC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAoB,EAAE,GAAQ;QACtE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;IAC5C,CAAC;IAEO,SAAS,CAAC,EAAU,EAAE,KAAoB,EAAE,GAAQ;QAC1D,MAAM,SAAS,GACb,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;QACzE,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;QAC9C,MAAM,gBAAgB,GACpB,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,KAAK,MAAM,CAAC;QAEtD,IAAI,cAAkC,CAAC;QACvC,IAAI,gBAAgB,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;YAC5C,MAAM,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC9C,cAAc,GAAG,gBAAE,CAAC,WAAW,CAAC,aAAa,SAAS,GAAG,YAAY,EAAE,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,QAAQ,GAAa;YACzB,SAAS;YACT,MAAM;YACN,cAAc;YACd,MAAM,EAAE,KAAK,CAAC,MAAM;YACpB,WAAW,EAAE,KAAK,CAAC,QAAQ;YAC3B,cAAc,EAAE,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ;YAChD,gBAAgB,EAAE,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,WAAW,CAAC;YAC1D,aAAa,EAAE,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,QAAQ,CAAC;YACxD,eAAe,EAAE,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,YAAY,CAAC;SACjE,CAAC;QAEF,OAAO,IAAI,SAAG,CAAC,IAAI,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC;IACrC,CAAC;IAEO,gBAAgB,CACtB,MAAqC;QAErC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC3C,IAAI,MAAM,KAAK,KAAK;YAAE,OAAO,KAAK,CAAC;QACnC,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;IACjC,CAAC;IAEO,oBAAoB,CAAC,MAAyC;QAQpE,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,SAAS,CAAC;QAC3C,IAAI,MAAM,KAAK,KAAK;YAAE,OAAO,KAAK,CAAC;QACnC,OAAO;YACL,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,aAAa,EAAE,MAAM,CAAC,aAAa;YACnC,WAAW,EAAE,MAAM,CAAC,WAAW;SAChC,CAAC;IACJ,CAAC;IAEO,sBAAsB,CAC5B,MAA8C;QAiB9C,IAAI,MAAM,KAAK,KAAK;YAAE,OAAO,KAAK,CAAC;QAEnC,qCAAqC;QACrC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,CAAC;QACnD,CAAC;QAED,OAAO;YACL,OAAO,EACL,MAAM,CAAC,OAAO,KAAK,KAAK;gBACtB,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC;oBACE,EAAE,EAAE,MAAM,CAAC,OAAO,EAAE,EAAE,IAAI,IAAI;oBAC9B,QAAQ,EAAE,MAAM,CAAC,OAAO,EAAE,QAAQ,IAAI,IAAI;iBAC3C;YACP,SAAS,EAAE,MAAM,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS;SACjE,CAAC;IACJ,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;CACF;AArGD,0BAqGC","sourcesContent":["import { Construct } from \"constructs\";\nimport { Fn } from \"aws-cdk-lib\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\n\nimport type App from \"../../app\";\nimport { Vpc, type VpcProps } from \"../../resources/aws/networking/vpc\";\n\nexport interface NatConfig {\n  count?: number;\n}\n\nexport interface FlowLogConfig {\n  destination?: \"cloudwatch\" | \"s3\";\n  retentionDays?: number;\n  trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n}\n\nexport interface GatewayEndpointsConfig {\n  s3?: boolean;\n  dynamodb?: boolean;\n}\n\nexport interface InterfaceEndpointsConfig {\n  ecr?: boolean;\n  secretsManager?: boolean;\n  kms?: boolean;\n  cloudwatchLogs?: boolean;\n  ssm?: boolean;\n  sts?: boolean;\n}\n\nexport interface VpcEndpointsConfig {\n  gateway?: GatewayEndpointsConfig | false;\n  interface?: InterfaceEndpointsConfig | false;\n}\n\nexport interface SubnetConfig {\n  cidrMask?: number;\n}\n\nexport interface SubnetsConfig {\n  public?: SubnetConfig;\n  private?: SubnetConfig;\n  isolated?: SubnetConfig | false;\n}\n\nexport interface TransitGatewayConfig {\n  id: string;\n}\n\n/**\n * Network (VPC) configuration.\n *\n * @example\n * // Minimal cost VPC (no NAT, gateway endpoints only)\n * { natGateways: false }\n *\n * @example\n * // Production VPC with 1 NAT gateway\n * { natGateways: { count: 1 }, flowLogs: {} }\n *\n * @example\n * // High-availability VPC with interface endpoints\n * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }\n */\nexport interface INetworkProps {\n  maxAzs?: number;\n  cidrMask?: number;\n  natGateways?: NatConfig | false;\n  flowLogs?: FlowLogConfig | false;\n  vpcEndpoints?: VpcEndpointsConfig | false;\n  subnets?: SubnetsConfig;\n  transitGateway?: TransitGatewayConfig;\n}\n\nfunction validateNetworkProps(props: INetworkProps): void {\n  if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {\n    console.warn(\n      `[Fjall] Warning: 'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`\n    );\n  }\n\n  if (\n    typeof props.natGateways === \"object\" &&\n    props.natGateways !== null &&\n    props.natGateways.count !== undefined\n  ) {\n    const maxAzs = props.maxAzs ?? 3;\n    if (props.natGateways.count > maxAzs) {\n      console.warn(\n        `[Fjall] Warning: 'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`\n      );\n    }\n  }\n\n  if (props.transitGateway && !props.transitGateway.id) {\n    throw new Error(\"Transit Gateway configuration requires 'id'.\");\n  }\n}\n\nexport class NetworkFactory {\n  static build(id: string, props: INetworkProps) {\n    return (app: App, scope: Construct) => {\n      validateNetworkProps(props);\n      return new Network(scope, id, props, app);\n    };\n  }\n}\n\nexport class Network extends Construct {\n  public readonly vpc: Vpc;\n\n  constructor(scope: Construct, id: string, props: INetworkProps, app: App) {\n    super(scope, id);\n    this.vpc = this.createVpc(id, props, app);\n  }\n\n  private createVpc(id: string, props: INetworkProps, app: App): Vpc {\n    const accountId =\n      app.node.tryGetContext(\"accountId\") || process.env.CDK_DEFAULT_ACCOUNT;\n    const region = process.env.CDK_DEFAULT_REGION;\n    const isManagedAccount =\n      app.node.tryGetContext(\"managedAccount\") === \"true\";\n\n    let ipv4IpamPoolId: string | undefined;\n    if (isManagedAccount && accountId && region) {\n      const regionSuffix = region.replace(/-/g, \"\");\n      ipv4IpamPoolId = Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);\n    }\n\n    const vpcProps: VpcProps = {\n      accountId,\n      region,\n      ipv4IpamPoolId,\n      maxAzs: props.maxAzs,\n      vpcCidrMask: props.cidrMask,\n      subnetCidrMask: props.subnets?.private?.cidrMask,\n      natGatewayConfig: this.resolveNatConfig(props.natGateways),\n      flowLogConfig: this.resolveFlowLogConfig(props.flowLogs),\n      endpointsConfig: this.resolveEndpointsConfig(props.vpcEndpoints)\n    };\n\n    return new Vpc(this, id, vpcProps);\n  }\n\n  private resolveNatConfig(\n    config: NatConfig | false | undefined\n  ): { count?: number } | false | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return { count: config.count };\n  }\n\n  private resolveFlowLogConfig(config: FlowLogConfig | false | undefined):\n    | {\n        destination?: \"cloudwatch\" | \"s3\";\n        retentionDays?: number;\n        trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n      }\n    | false\n    | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return {\n      destination: config.destination,\n      retentionDays: config.retentionDays,\n      trafficType: config.trafficType\n    };\n  }\n\n  private resolveEndpointsConfig(\n    config: VpcEndpointsConfig | false | undefined\n  ):\n    | {\n        gateway?: { s3?: boolean; dynamodb?: boolean } | false;\n        interface?:\n          | {\n              ecr?: boolean;\n              secretsManager?: boolean;\n              kms?: boolean;\n              cloudwatchLogs?: boolean;\n              ssm?: boolean;\n              sts?: boolean;\n            }\n          | false;\n      }\n    | false\n    | undefined {\n    if (config === false) return false;\n\n    // Default: gateway endpoints enabled\n    if (config === undefined) {\n      return { gateway: { s3: true, dynamodb: true } };\n    }\n\n    return {\n      gateway:\n        config.gateway === false\n          ? false\n          : {\n              s3: config.gateway?.s3 ?? true,\n              dynamodb: config.gateway?.dynamodb ?? true\n            },\n      interface: config.interface === false ? false : config.interface\n    };\n  }\n\n  getVpc(): IVpc {\n    return this.vpc;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/network.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from \"constructs\";\nimport { Fn } from \"aws-cdk-lib\";\nimport { type IVpc } from \"aws-cdk-lib/aws-ec2\";\n\nimport type App from \"../../app\";\nimport { Vpc, type VpcProps } from \"../../resources/aws/networking/vpc\";\n\nexport interface NatConfig {\n  count?: number;\n}\n\nexport interface FlowLogConfig {\n  destination?: \"cloudwatch\" | \"s3\";\n  retentionDays?: number;\n  trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n}\n\nexport interface GatewayEndpointsConfig {\n  s3?: boolean;\n  dynamodb?: boolean;\n}\n\nexport interface InterfaceEndpointsConfig {\n  ecr?: boolean;\n  secretsManager?: boolean;\n  kms?: boolean;\n  cloudwatchLogs?: boolean;\n  ssm?: boolean;\n  sts?: boolean;\n}\n\nexport interface VpcEndpointsConfig {\n  gateway?: GatewayEndpointsConfig | false;\n  interface?: InterfaceEndpointsConfig | false;\n}\n\nexport interface SubnetConfig {\n  cidrMask?: number;\n}\n\nexport interface SubnetsConfig {\n  public?: SubnetConfig;\n  private?: SubnetConfig;\n  isolated?: SubnetConfig | false;\n}\n\nexport interface TransitGatewayConfig {\n  id: string;\n}\n\n/**\n * Network (VPC) configuration.\n *\n * @example\n * // Minimal cost VPC (no NAT, gateway endpoints only)\n * { natGateways: false }\n *\n * @example\n * // Production VPC with 1 NAT gateway\n * { natGateways: { count: 1 }, flowLogs: {} }\n *\n * @example\n * // High-availability VPC with interface endpoints\n * { maxAzs: 3, natGateways: { count: 3 }, vpcEndpoints: { interface: { ecr: true } } }\n */\nexport interface INetworkProps {\n  vpcName?: string;\n  maxAzs?: number;\n  cidrMask?: number;\n  natGateways?: NatConfig | false;\n  flowLogs?: FlowLogConfig | false;\n  vpcEndpoints?: VpcEndpointsConfig | false;\n  subnets?: SubnetsConfig;\n  transitGateway?: TransitGatewayConfig;\n}\n\nfunction validateNetworkProps(props: INetworkProps): void {\n  if (props.maxAzs !== undefined && (props.maxAzs < 1 || props.maxAzs > 3)) {\n    console.warn(\n      `[Fjall] Warning: 'maxAzs' should be between 1 and 3. Got: ${props.maxAzs}.`\n    );\n  }\n\n  if (\n    typeof props.natGateways === \"object\" &&\n    props.natGateways !== null &&\n    props.natGateways.count !== undefined\n  ) {\n    const maxAzs = props.maxAzs ?? 3;\n    if (props.natGateways.count > maxAzs) {\n      console.warn(\n        `[Fjall] Warning: 'natGateways.count' (${props.natGateways.count}) exceeds maxAzs (${maxAzs}).`\n      );\n    }\n  }\n\n  if (props.transitGateway && !props.transitGateway.id) {\n    throw new Error(\"Transit Gateway configuration requires 'id'.\");\n  }\n}\n\nexport class NetworkFactory {\n  static build(id: string, props: INetworkProps) {\n    return (app: App, scope: Construct) => {\n      validateNetworkProps(props);\n      return new Network(scope, id, props, app);\n    };\n  }\n}\n\nexport class Network extends Construct {\n  public readonly vpc: Vpc;\n\n  constructor(scope: Construct, id: string, props: INetworkProps, app: App) {\n    super(scope, id);\n    this.vpc = this.createVpc(id, props, app);\n  }\n\n  private createVpc(id: string, props: INetworkProps, app: App): Vpc {\n    const accountId =\n      app.node.tryGetContext(\"accountId\") || process.env.CDK_DEFAULT_ACCOUNT;\n    const region = process.env.CDK_DEFAULT_REGION;\n    const isManagedAccount =\n      app.node.tryGetContext(\"managedAccount\") === \"true\";\n\n    let ipv4IpamPoolId: string | undefined;\n    if (isManagedAccount && accountId && region) {\n      const regionSuffix = region.replace(/-/g, \"\");\n      ipv4IpamPoolId = Fn.importValue(`IpamPoolId${accountId}${regionSuffix}`);\n    }\n\n    const vpcProps: VpcProps = {\n      vpcName: props.vpcName,\n      accountId,\n      region,\n      ipv4IpamPoolId,\n      maxAzs: props.maxAzs,\n      vpcCidrMask: props.cidrMask,\n      subnetCidrMask: props.subnets?.private?.cidrMask,\n      natGatewayConfig: this.resolveNatConfig(props.natGateways),\n      flowLogConfig: this.resolveFlowLogConfig(props.flowLogs),\n      endpointsConfig: this.resolveEndpointsConfig(props.vpcEndpoints)\n    };\n\n    return new Vpc(this, id, vpcProps);\n  }\n\n  private resolveNatConfig(\n    config: NatConfig | false | undefined\n  ): { count?: number } | false | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return { count: config.count };\n  }\n\n  private resolveFlowLogConfig(config: FlowLogConfig | false | undefined):\n    | {\n        destination?: \"cloudwatch\" | \"s3\";\n        retentionDays?: number;\n        trafficType?: \"ALL\" | \"ACCEPT\" | \"REJECT\";\n      }\n    | false\n    | undefined {\n    if (config === undefined) return undefined;\n    if (config === false) return false;\n    return {\n      destination: config.destination,\n      retentionDays: config.retentionDays,\n      trafficType: config.trafficType\n    };\n  }\n\n  private resolveEndpointsConfig(\n    config: VpcEndpointsConfig | false | undefined\n  ):\n    | {\n        gateway?: { s3?: boolean; dynamodb?: boolean } | false;\n        interface?:\n          | {\n              ecr?: boolean;\n              secretsManager?: boolean;\n              kms?: boolean;\n              cloudwatchLogs?: boolean;\n              ssm?: boolean;\n              sts?: boolean;\n            }\n          | false;\n      }\n    | false\n    | undefined {\n    if (config === false) return false;\n\n    // Default: gateway endpoints enabled\n    if (config === undefined) {\n      return { gateway: { s3: true, dynamodb: true } };\n    }\n\n    return {\n      gateway:\n        config.gateway === false\n          ? false\n          : {\n              s3: config.gateway?.s3 ?? true,\n              dynamodb: config.gateway?.dynamodb ?? true\n            },\n      interface: config.interface === false ? false : config.interface\n    };\n  }\n\n  getVpc(): IVpc {\n    return this.vpc;\n  }\n}\n"]}

package/dist/lib/resources/aws/compute/capacityProviderDrainWaiter.d.ts

@@ -0,0 +1,20 @@
+import { Construct } from "constructs";
+/**
+ * Props for CapacityProviderDrainWaiter
+ */
+interface CapacityProviderDrainWaiterProps {
+    /** The ECS cluster name */
+    clusterName: string;
+    /** The capacity provider name to wait for */
+    capacityProviderName: string;
+}
+/**
+ * Custom resource that waits for ECS services to drain before allowing
+ * capacity provider disassociation.
+ *
+ * @see https://github.com/aws/aws-cdk/issues/14732
+ */
+export declare class CapacityProviderDrainWaiter extends Construct {
+    constructor(scope: Construct, id: string, props: CapacityProviderDrainWaiterProps);
+}
+export {};

package/dist/lib/resources/aws/compute/capacityProviderDrainWaiter.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapacityProviderDrainWaiter = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const constructs_1 = require("constructs");
+const customResource_1 = require("../utilities/customResource");
+/**
+ * Custom resource that waits for ECS services to drain before allowing
+ * capacity provider disassociation.
+ *
+ * @see https://github.com/aws/aws-cdk/issues/14732
+ */
+class CapacityProviderDrainWaiter extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { clusterName, capacityProviderName } = props;
+        // Lambda inline code for the custom resource handler
+        const handlerCode = `
+const { ECSClient, ListServicesCommand, DescribeServicesCommand, PutClusterCapacityProvidersCommand, DescribeClustersCommand } = require("@aws-sdk/client-ecs");
+
+const ecsClient = new ECSClient({});
+const POLL_INTERVAL_MS = 5000;
+const MAX_WAIT_MS = 300000; // 5 minutes
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function getClusterCapacityProviders(clusterName) {
+  const response = await ecsClient.send(new DescribeClustersCommand({
+    clusters: [clusterName]
+  }));
+  return response.clusters?.[0]?.capacityProviders || [];
+}
+
+async function waitForServicesDrained(clusterName, capacityProviderName) {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < MAX_WAIT_MS) {
+    // List all services in the cluster
+    const listResponse = await ecsClient.send(new ListServicesCommand({
+      cluster: clusterName,
+      maxResults: 100
+    }));
+
+    const serviceArns = listResponse.serviceArns || [];
+
+    if (serviceArns.length === 0) {
+      console.log("No services found in cluster - drain complete");
+      return true;
+    }
+
+    // Describe services to check running counts
+    const describeResponse = await ecsClient.send(new DescribeServicesCommand({
+      cluster: clusterName,
+      services: serviceArns
+    }));
+
+    const activeServices = (describeResponse.services || []).filter(svc => {
+      // Check if service uses this capacity provider
+      const usesCapacityProvider = (svc.capacityProviderStrategy || [])
+        .some(strategy => strategy.capacityProvider === capacityProviderName);
+
+      // Only care about services using this capacity provider that still have running tasks
+      return usesCapacityProvider && svc.runningCount > 0;
+    });
+
+    if (activeServices.length === 0) {
+      console.log("All services using capacity provider have drained");
+      return true;
+    }
+
+    console.log(\`Waiting for \${activeServices.length} services to drain: \${activeServices.map(s => s.serviceName).join(", ")}\`);
+    await sleep(POLL_INTERVAL_MS);
+  }
+
+  console.log("Timeout waiting for services to drain, proceeding anyway");
+  return false;
+}
+
+async function disassociateCapacityProvider(clusterName, capacityProviderName) {
+  try {
+    // Get current capacity providers
+    const currentProviders = await getClusterCapacityProviders(clusterName);
+
+    // Filter out the one we want to remove
+    const remainingProviders = currentProviders.filter(cp => cp !== capacityProviderName);
+
+    if (remainingProviders.length === currentProviders.length) {
+      console.log(\`Capacity provider \${capacityProviderName} not associated with cluster\`);
+      return true;
+    }
+
+    // Ensure we keep at least FARGATE as a provider (required by ECS)
+    if (remainingProviders.length === 0) {
+      remainingProviders.push("FARGATE");
+    }
+
+    console.log(\`Disassociating \${capacityProviderName} from cluster. Remaining: \${remainingProviders.join(", ")}\`);
+
+    await ecsClient.send(new PutClusterCapacityProvidersCommand({
+      cluster: clusterName,
+      capacityProviders: remainingProviders,
+      defaultCapacityProviderStrategy: []
+    }));
+
+    console.log("Successfully disassociated capacity provider");
+    return true;
+  } catch (error) {
+    // If cluster or capacity provider doesn't exist, that's fine (already deleted)
+    if (error.name === "ClusterNotFoundException" ||
+        error.name === "ResourceNotFoundException" ||
+        error.message?.includes("does not exist")) {
+      console.log("Cluster or capacity provider not found - already cleaned up");
+      return true;
+    }
+    throw error;
+  }
+}
+
+exports.handler = async (event) => {
+  console.log("Event:", JSON.stringify(event, null, 2));
+
+  const clusterName = event.ResourceProperties.ClusterName;
+  const capacityProviderName = event.ResourceProperties.CapacityProviderName;
+  const requestType = event.RequestType;
+
+  try {
+    if (requestType === "Delete") {
+      console.log(\`Handling DELETE for capacity provider \${capacityProviderName} in cluster \${clusterName}\`);
+
+      // Wait for services to drain
+      await waitForServicesDrained(clusterName, capacityProviderName);
+
+      // Disassociate capacity provider from cluster
+      await disassociateCapacityProvider(clusterName, capacityProviderName);
+    }
+
+    // Return success for all request types
+    return {
+      PhysicalResourceId: \`\${clusterName}-\${capacityProviderName}-drain-waiter\`,
+      Data: {
+        Message: \`\${requestType} completed successfully\`
+      }
+    };
+  } catch (error) {
+    console.error("Error:", error);
+    throw error;
+  }
+};
+`;
+        new customResource_1.CustomResource(this, "DrainWaiter", {
+            runtime: aws_lambda_1.Runtime.NODEJS_22_X,
+            inlineCode: handlerCode,
+            timeout: aws_cdk_lib_1.Duration.minutes(6),
+            lambdaDescription: `Waits for ECS services to drain before capacity provider disassociation`,
+            roleDescription: `Role for ${clusterName} capacity provider drain waiter`,
+            inlinePolicy: [
+                new aws_iam_1.PolicyStatement({
+                    effect: aws_iam_1.Effect.ALLOW,
+                    actions: [
+                        "ecs:ListServices",
+                        "ecs:DescribeServices",
+                        "ecs:DescribeClusters",
+                        "ecs:PutClusterCapacityProviders"
+                    ],
+                    resources: ["*"]
+                })
+            ],
+            properties: {
+                ClusterName: clusterName,
+                CapacityProviderName: capacityProviderName
+            }
+        });
+    }
+}
+exports.CapacityProviderDrainWaiter = CapacityProviderDrainWaiter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capacityProviderDrainWaiter.js","sourceRoot":"","sources":["../../../../../lib/resources/aws/compute/capacityProviderDrainWaiter.ts"],"names":[],"mappings":";;;AAAA,6CAAuC;AACvC,iDAA8D;AAC9D,uDAAiD;AACjD,2CAAuC;AACvC,gEAA6D;AAY7D;;;;;GAKG;AACH,MAAa,2BAA4B,SAAQ,sBAAS;IACxD,YACE,KAAgB,EAChB,EAAU,EACV,KAAuC;QAEvC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EAAE,WAAW,EAAE,oBAAoB,EAAE,GAAG,KAAK,CAAC;QAEpD,qDAAqD;QACrD,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqIvB,CAAC;QAEE,IAAI,+BAAc,CAAC,IAAI,EAAE,aAAa,EAAE;YACtC,OAAO,EAAE,oBAAO,CAAC,WAAW;YAC5B,UAAU,EAAE,WAAW;YACvB,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;YAC5B,iBAAiB,EAAE,yEAAyE;YAC5F,eAAe,EAAE,YAAY,WAAW,iCAAiC;YACzE,YAAY,EAAE;gBACZ,IAAI,yBAAe,CAAC;oBAClB,MAAM,EAAE,gBAAM,CAAC,KAAK;oBACpB,OAAO,EAAE;wBACP,kBAAkB;wBAClB,sBAAsB;wBACtB,sBAAsB;wBACtB,iCAAiC;qBAClC;oBACD,SAAS,EAAE,CAAC,GAAG,CAAC;iBACjB,CAAC;aACH;YACD,UAAU,EAAE;gBACV,WAAW,EAAE,WAAW;gBACxB,oBAAoB,EAAE,oBAAoB;aAC3C;SACF,CAAC,CAAC;IACL,CAAC;CACF;AA1KD,kEA0KC","sourcesContent":["import { Duration } from \"aws-cdk-lib\";\nimport { PolicyStatement, Effect } from \"aws-cdk-lib/aws-iam\";\nimport { Runtime } from \"aws-cdk-lib/aws-lambda\";\nimport { Construct } from \"constructs\";\nimport { CustomResource } from \"../utilities/customResource\";\n\n/**\n * Props for CapacityProviderDrainWaiter\n */\ninterface CapacityProviderDrainWaiterProps {\n  /** The ECS cluster name */\n  clusterName: string;\n  /** The capacity provider name to wait for */\n  capacityProviderName: string;\n}\n\n/**\n * Custom resource that waits for ECS services to drain before allowing\n * capacity provider disassociation.\n *\n * @see https://github.com/aws/aws-cdk/issues/14732\n */\nexport class CapacityProviderDrainWaiter extends Construct {\n  constructor(\n    scope: Construct,\n    id: string,\n    props: CapacityProviderDrainWaiterProps\n  ) {\n    super(scope, id);\n\n    const { clusterName, capacityProviderName } = props;\n\n    // Lambda inline code for the custom resource handler\n    const handlerCode = `\nconst { ECSClient, ListServicesCommand, DescribeServicesCommand, PutClusterCapacityProvidersCommand, DescribeClustersCommand } = require(\"@aws-sdk/client-ecs\");\n\nconst ecsClient = new ECSClient({});\nconst POLL_INTERVAL_MS = 5000;\nconst MAX_WAIT_MS = 300000; // 5 minutes\n\nasync function sleep(ms) {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\nasync function getClusterCapacityProviders(clusterName) {\n  const response = await ecsClient.send(new DescribeClustersCommand({\n    clusters: [clusterName]\n  }));\n  return response.clusters?.[0]?.capacityProviders || [];\n}\n\nasync function waitForServicesDrained(clusterName, capacityProviderName) {\n  const startTime = Date.now();\n\n  while (Date.now() - startTime < MAX_WAIT_MS) {\n    // List all services in the cluster\n    const listResponse = await ecsClient.send(new ListServicesCommand({\n      cluster: clusterName,\n      maxResults: 100\n    }));\n\n    const serviceArns = listResponse.serviceArns || [];\n\n    if (serviceArns.length === 0) {\n      console.log(\"No services found in cluster - drain complete\");\n      return true;\n    }\n\n    // Describe services to check running counts\n    const describeResponse = await ecsClient.send(new DescribeServicesCommand({\n      cluster: clusterName,\n      services: serviceArns\n    }));\n\n    const activeServices = (describeResponse.services || []).filter(svc => {\n      // Check if service uses this capacity provider\n      const usesCapacityProvider = (svc.capacityProviderStrategy || [])\n        .some(strategy => strategy.capacityProvider === capacityProviderName);\n\n      // Only care about services using this capacity provider that still have running tasks\n      return usesCapacityProvider && svc.runningCount > 0;\n    });\n\n    if (activeServices.length === 0) {\n      console.log(\"All services using capacity provider have drained\");\n      return true;\n    }\n\n    console.log(\\`Waiting for \\${activeServices.length} services to drain: \\${activeServices.map(s => s.serviceName).join(\", \")}\\`);\n    await sleep(POLL_INTERVAL_MS);\n  }\n\n  console.log(\"Timeout waiting for services to drain, proceeding anyway\");\n  return false;\n}\n\nasync function disassociateCapacityProvider(clusterName, capacityProviderName) {\n  try {\n    // Get current capacity providers\n    const currentProviders = await getClusterCapacityProviders(clusterName);\n\n    // Filter out the one we want to remove\n    const remainingProviders = currentProviders.filter(cp => cp !== capacityProviderName);\n\n    if (remainingProviders.length === currentProviders.length) {\n      console.log(\\`Capacity provider \\${capacityProviderName} not associated with cluster\\`);\n      return true;\n    }\n\n    // Ensure we keep at least FARGATE as a provider (required by ECS)\n    if (remainingProviders.length === 0) {\n      remainingProviders.push(\"FARGATE\");\n    }\n\n    console.log(\\`Disassociating \\${capacityProviderName} from cluster. Remaining: \\${remainingProviders.join(\", \")}\\`);\n\n    await ecsClient.send(new PutClusterCapacityProvidersCommand({\n      cluster: clusterName,\n      capacityProviders: remainingProviders,\n      defaultCapacityProviderStrategy: []\n    }));\n\n    console.log(\"Successfully disassociated capacity provider\");\n    return true;\n  } catch (error) {\n    // If cluster or capacity provider doesn't exist, that's fine (already deleted)\n    if (error.name === \"ClusterNotFoundException\" ||\n        error.name === \"ResourceNotFoundException\" ||\n        error.message?.includes(\"does not exist\")) {\n      console.log(\"Cluster or capacity provider not found - already cleaned up\");\n      return true;\n    }\n    throw error;\n  }\n}\n\nexports.handler = async (event) => {\n  console.log(\"Event:\", JSON.stringify(event, null, 2));\n\n  const clusterName = event.ResourceProperties.ClusterName;\n  const capacityProviderName = event.ResourceProperties.CapacityProviderName;\n  const requestType = event.RequestType;\n\n  try {\n    if (requestType === \"Delete\") {\n      console.log(\\`Handling DELETE for capacity provider \\${capacityProviderName} in cluster \\${clusterName}\\`);\n\n      // Wait for services to drain\n      await waitForServicesDrained(clusterName, capacityProviderName);\n\n      // Disassociate capacity provider from cluster\n      await disassociateCapacityProvider(clusterName, capacityProviderName);\n    }\n\n    // Return success for all request types\n    return {\n      PhysicalResourceId: \\`\\${clusterName}-\\${capacityProviderName}-drain-waiter\\`,\n      Data: {\n        Message: \\`\\${requestType} completed successfully\\`\n      }\n    };\n  } catch (error) {\n    console.error(\"Error:\", error);\n    throw error;\n  }\n};\n`;\n\n    new CustomResource(this, \"DrainWaiter\", {\n      runtime: Runtime.NODEJS_22_X,\n      inlineCode: handlerCode,\n      timeout: Duration.minutes(6),\n      lambdaDescription: `Waits for ECS services to drain before capacity provider disassociation`,\n      roleDescription: `Role for ${clusterName} capacity provider drain waiter`,\n      inlinePolicy: [\n        new PolicyStatement({\n          effect: Effect.ALLOW,\n          actions: [\n            \"ecs:ListServices\",\n            \"ecs:DescribeServices\",\n            \"ecs:DescribeClusters\",\n            \"ecs:PutClusterCapacityProviders\"\n          ],\n          resources: [\"*\"]\n        })\n      ],\n      properties: {\n        ClusterName: clusterName,\n        CapacityProviderName: capacityProviderName\n      }\n    });\n  }\n}\n"]}