@fjall/components-infrastructure 0.79.1 → 0.80.4

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

@@ -0,0 +1,163 @@
+import { Construct } from "constructs";
+import { ApplicationLoadBalancer, ApplicationListener, ApplicationTargetGroup, type IApplicationTargetGroup } from "aws-cdk-lib/aws-elasticloadbalancingv2";
+import { Certificate } from "aws-cdk-lib/aws-certificatemanager";
+import { Connections, type IConnectable, type IVpc, Port, SecurityGroup } from "aws-cdk-lib/aws-ec2";
+import type App from "../../app";
+import { HostedZone as FjallHostedZone } from "./hostedZone";
+/**
+ * Routing configuration for registering services with the load balancer.
+ */
+export interface LoadBalancerRoutingConfig {
+    /**
+     * Path pattern(s) to match. Examples: "/api/*", ["/api/*", "/v1/*"]
+     */
+    path?: string | string[];
+    /**
+     * Host pattern(s) to match. Examples: "api.example.com", ["api.example.com", "www.example.com"]
+     */
+    host?: string | string[];
+    /**
+     * Priority for this routing rule. Lower numbers = higher priority.
+     * Must be unique per listener. Range: 1-50000.
+     */
+    priority: number;
+    /**
+     * Health check path for this target group. Default: "/"
+     */
+    healthCheckPath?: string;
+}
+/**
+ * Health check configuration for the load balancer.
+ */
+export interface LoadBalancerHealthCheckConfig {
+    /** Health check path. Default: "/" */
+    path?: string;
+    /** Interval between health checks in seconds. Default: 30 */
+    interval?: number;
+    /** Health check timeout in seconds. Default: 5 */
+    timeout?: number;
+    /** Number of consecutive successes before healthy. Default: 2 */
+    healthyThreshold?: number;
+    /** Number of consecutive failures before unhealthy. Default: 3 */
+    unhealthyThreshold?: number;
+}
+/**
+ * Domain configuration for HTTPS and DNS.
+ */
+export interface LoadBalancerDomainConfig {
+    /** Domain name (e.g., "api.example.com") */
+    name: string;
+    /** Existing hosted zone. If omitted, creates new one. */
+    hostedZone?: FjallHostedZone;
+    /** Existing certificate. If omitted, creates new one with DNS validation. */
+    certificate?: Certificate;
+}
+/**
+ * Properties for LoadBalancerFactory.build()
+ */
+export interface ILoadBalancerProps {
+    /** VPC to place the load balancer in. Default: app's default VPC */
+    vpc?: IVpc;
+    /**
+     * Domain configuration for HTTPS.
+     * - string: Domain name (creates hosted zone and certificate)
+     * - LoadBalancerDomainConfig: Full configuration
+     * - Omit: HTTP only
+     */
+    domain?: string | LoadBalancerDomainConfig;
+    /**
+     * Whether the load balancer is internet-facing.
+     * Default: true
+     */
+    public?: boolean;
+    /**
+     * Default health check configuration.
+     * Individual services can override this.
+     */
+    healthCheck?: LoadBalancerHealthCheckConfig;
+}
+/**
+ * Internal props with resolved VPC.
+ */
+interface LoadBalancerPropsResolved extends ILoadBalancerProps {
+    vpc: IVpc;
+}
+/**
+ * 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
+ *   })
+ * );
+ */
+export declare class LoadBalancerFactory {
+    static build(id: string, props: ILoadBalancerProps): (app: App, scope: Construct) => LoadBalancer;
+}
+/**
+ * Application Load Balancer construct that can be shared across multiple ECS services.
+ *
+ * Use LoadBalancerFactory.build() to create instances via app.addCompute().
+ */
+export declare class LoadBalancer extends Construct implements IConnectable {
+    readonly alb: ApplicationLoadBalancer;
+    readonly listener: ApplicationListener;
+    readonly securityGroup: SecurityGroup;
+    readonly url: string;
+    readonly connections: Connections;
+    private readonly hostedZone?;
+    private readonly certificate?;
+    private readonly defaultHealthCheck;
+    private readonly isHttps;
+    constructor(scope: Construct, id: string, props: LoadBalancerPropsResolved);
+    /**
+     * 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: IApplicationTargetGroup, routing: LoadBalancerRoutingConfig): void;
+    /**
+     * 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: string, port: number, vpc: IVpc, healthCheckPath?: string): ApplicationTargetGroup;
+    /**
+     * Allow traffic from this load balancer to a connectable resource.
+     */
+    allowTo(connectable: IConnectable, port?: Port): void;
+    private normaliseDomainConfig;
+    private setupDomain;
+    private truncateName;
+    /**
+     * Get the DNS name of the load balancer.
+     */
+    getDnsName(): string;
+    /**
+     * Get the ARN of the load balancer.
+     */
+    getArn(): string;
+}
+export {};

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/managedAccount.js

@@ -4,7 +4,6 @@ exports.ManagedAccount = void 0;
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 const aws_1 = require("../../config/aws");
 const cloudTrail_1 = require("../../config/aws/cloudTrail");
-const aws_cdk_lib_2 = require("aws-cdk-lib");
 const getConfig_1 = require("../../utils/getConfig");
 const disasterRecovery_1 = require("../../config/aws/disasterRecovery");
 const util_1 = require("@fjall/util");
@@ -32,7 +31,7 @@ class ManagedAccount extends aws_cdk_lib_1.Stack {
         });
         const config = (0, getConfig_1.getConfig)();
         const environment = config.environment || "unknown";
-        const fjallConfig = util_1.Config.loadConfig();
+        const _fjallConfig = util_1.Config.loadConfig();
         const isComplianceAccount = environment === "compliance";
         const isReplicationRegion = config.disasterRecoveryRegion &&
             props.region === config.disasterRecoveryRegion;
@@ -44,7 +43,7 @@ class ManagedAccount extends aws_cdk_lib_1.Stack {
                 accountId: props.accountId
             });
         }
-        new aws_cdk_lib_2.CfnOutput(this, "Environment", {
+        new aws_cdk_lib_1.CfnOutput(this, "Environment", {
             key: "Environment",
             value: environment,
             exportName: "Environment",
@@ -53,4 +52,4 @@ class ManagedAccount extends aws_cdk_lib_1.Stack {
     }
 }
 exports.ManagedAccount = ManagedAccount;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,61 @@
+import { Construct } from "constructs";
+import type App from "../../app";
+import { SQSQueue } from "../../resources/aws/messaging/sqs";
+export interface ISQSProps {
+    queueType?: "standard" | "fifo";
+    visibilityTimeout?: number;
+    messageRetentionPeriod?: number;
+    receiveMessageWaitTime?: number;
+    maxMessageSize?: number;
+    deliveryDelay?: number;
+    deadLetterQueue?: {
+        enabled: boolean;
+        maxReceiveCount?: number;
+    };
+    encryption?: "SSE_SQS" | "SSE_KMS" | "NONE";
+    kmsKeyArn?: string;
+    contentBasedDeduplication?: boolean;
+    fifoThroughputLimit?: "perQueue" | "perMessageGroupId";
+    deduplicationScope?: "queue" | "messageGroup";
+    removalPolicy?: "DESTROY" | "RETAIN";
+}
+/**
+ * SQS queue wrapper with grant methods and Fjall patterns.
+ */
+export declare class Queue extends SQSQueue {
+    constructor(scope: Construct, id: string, props: ISQSProps);
+}
+/**
+ * Factory for creating SQS queues.
+ *
+ * @example
+ * // Standard queue with DLQ
+ * const notifications = app.addQueue(QueueFactory.build("Notifications", {
+ *   queueType: "standard",
+ *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }
+ * }));
+ *
+ * @example
+ * // FIFO queue for OpenNext revalidation
+ * const revalidation = app.addQueue(QueueFactory.build("Revalidation", {
+ *   queueType: "fifo",
+ *   visibilityTimeout: 300,
+ *   contentBasedDeduplication: true
+ * }));
+ *
+ * @example
+ * // Grant permissions
+ * revalidation.grantSend(serverFunction);
+ * revalidation.grantConsume(revalidationFunction);
+ */
+export declare class QueueFactory {
+    /**
+     * Build an SQS queue factory function.
+     *
+     * @param id - Unique identifier for the queue
+     * @param props - SQS queue configuration properties
+     * @returns Factory function that creates the queue when invoked
+     */
+    static build(id: string, props?: ISQSProps): (_app: App, scope: Construct) => Queue;
+}
+export type { SQSQueueProps } from "../../resources/aws/messaging/sqs";