@fjall/components-infrastructure 0.79.3 → 0.80.4

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";

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueFactory = exports.Queue = void 0;
+const sqs_1 = require("../../resources/aws/messaging/sqs");
+/**
+ * Validates SQS props and logs warnings for misconfigured options.
+ */
+function validateSQSProps(props) {
+    // Validate visibility timeout range (0-43200 seconds = 12 hours)
+    if (props.visibilityTimeout !== undefined &&
+        (props.visibilityTimeout < 0 || props.visibilityTimeout > 43200)) {
+        throw new Error("visibilityTimeout must be between 0 and 43200 seconds (12 hours)");
+    }
+    // Validate message retention period (60-1209600 seconds = 1 minute to 14 days)
+    if (props.messageRetentionPeriod !== undefined &&
+        (props.messageRetentionPeriod < 60 || props.messageRetentionPeriod > 1209600)) {
+        throw new Error("messageRetentionPeriod must be between 60 and 1209600 seconds (1 minute to 14 days)");
+    }
+    // Warn about FIFO-specific options on standard queues
+    if (props.queueType !== "fifo") {
+        if (props.contentBasedDeduplication !== undefined) {
+            console.warn("[Fjall] Warning: 'contentBasedDeduplication' is only applicable to FIFO queues. " +
+                "This setting will be ignored for standard queues.");
+        }
+        if (props.fifoThroughputLimit !== undefined) {
+            console.warn("[Fjall] Warning: 'fifoThroughputLimit' is only applicable to FIFO queues. " +
+                "This setting will be ignored for standard queues.");
+        }
+        if (props.deduplicationScope !== undefined) {
+            console.warn("[Fjall] Warning: 'deduplicationScope' is only applicable to FIFO queues. " +
+                "This setting will be ignored for standard queues.");
+        }
+    }
+    // Validate KMS encryption
+    if (props.kmsKeyArn && props.encryption !== "SSE_KMS") {
+        console.warn("[Fjall] Warning: 'kmsKeyArn' provided but 'encryption' is not SSE_KMS. " +
+            "The KMS key will be ignored.");
+    }
+}
+/**
+ * SQS queue wrapper with grant methods and Fjall patterns.
+ */
+class Queue extends sqs_1.SQSQueue {
+    constructor(scope, id, props) {
+        const queueProps = {
+            queueType: props.queueType,
+            visibilityTimeout: props.visibilityTimeout,
+            messageRetentionPeriod: props.messageRetentionPeriod,
+            receiveMessageWaitTime: props.receiveMessageWaitTime,
+            maxMessageSize: props.maxMessageSize,
+            deliveryDelay: props.deliveryDelay,
+            deadLetterQueue: props.deadLetterQueue,
+            encryption: props.encryption,
+            kmsKeyArn: props.kmsKeyArn,
+            contentBasedDeduplication: props.contentBasedDeduplication,
+            fifoThroughputLimit: props.fifoThroughputLimit,
+            deduplicationScope: props.deduplicationScope,
+            removalPolicy: props.removalPolicy
+        };
+        super(scope, id, queueProps);
+    }
+}
+exports.Queue = Queue;
+/**
+ * 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);
+ */
+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, props = {}) {
+        return (_app, scope) => {
+            validateSQSProps(props);
+            return new Queue(scope, id, props);
+        };
+    }
+}
+exports.QueueFactory = QueueFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../lib/patterns/aws/queue.ts"],"names":[],"mappings":";;;AAKA,2DAAiF;AAqBjF;;GAEG;AACH,SAAS,gBAAgB,CAAC,KAAgB;IACxC,iEAAiE;IACjE,IACE,KAAK,CAAC,iBAAiB,KAAK,SAAS;QACrC,CAAC,KAAK,CAAC,iBAAiB,GAAG,CAAC,IAAI,KAAK,CAAC,iBAAiB,GAAG,KAAK,CAAC,EAChE,CAAC;QACD,MAAM,IAAI,KAAK,CACb,kEAAkE,CACnE,CAAC;IACJ,CAAC;IAED,+EAA+E;IAC/E,IACE,KAAK,CAAC,sBAAsB,KAAK,SAAS;QAC1C,CAAC,KAAK,CAAC,sBAAsB,GAAG,EAAE,IAAI,KAAK,CAAC,sBAAsB,GAAG,OAAO,CAAC,EAC7E,CAAC;QACD,MAAM,IAAI,KAAK,CACb,qFAAqF,CACtF,CAAC;IACJ,CAAC;IAED,sDAAsD;IACtD,IAAI,KAAK,CAAC,SAAS,KAAK,MAAM,EAAE,CAAC;QAC/B,IAAI,KAAK,CAAC,yBAAyB,KAAK,SAAS,EAAE,CAAC;YAClD,OAAO,CAAC,IAAI,CACV,kFAAkF;gBAChF,mDAAmD,CACtD,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,mBAAmB,KAAK,SAAS,EAAE,CAAC;YAC5C,OAAO,CAAC,IAAI,CACV,4EAA4E;gBAC1E,mDAAmD,CACtD,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;YAC3C,OAAO,CAAC,IAAI,CACV,2EAA2E;gBACzE,mDAAmD,CACtD,CAAC;QACJ,CAAC;IACH,CAAC;IAED,0BAA0B;IAC1B,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;QACtD,OAAO,CAAC,IAAI,CACV,yEAAyE;YACvE,8BAA8B,CACjC,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAa,KAAM,SAAQ,cAAQ;IACjC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAgB;QACxD,MAAM,UAAU,GAAkB;YAChC,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,iBAAiB,EAAE,KAAK,CAAC,iBAAiB;YAC1C,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,sBAAsB,EAAE,KAAK,CAAC,sBAAsB;YACpD,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,aAAa,EAAE,KAAK,CAAC,aAAa;YAClC,eAAe,EAAE,KAAK,CAAC,eAAe;YACtC,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,yBAAyB,EAAE,KAAK,CAAC,yBAAyB;YAC1D,mBAAmB,EAAE,KAAK,CAAC,mBAAmB;YAC9C,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,aAAa,EAAE,KAAK,CAAC,aAAa;SACnC,CAAC;QACF,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,UAAU,CAAC,CAAC;IAC/B,CAAC;CACF;AAnBD,sBAmBC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAa,YAAY;IACvB;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,EAAU,EAAE,QAAmB,EAAE;QAC5C,OAAO,CAAC,IAAS,EAAE,KAAgB,EAAS,EAAE;YAC5C,gBAAgB,CAAC,KAAK,CAAC,CAAC;YACxB,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACrC,CAAC,CAAC;IACJ,CAAC;CACF;AAdD,oCAcC","sourcesContent":["import { Construct } from \"constructs\";\nimport { type IGrantable, type Grant } from \"aws-cdk-lib/aws-iam\";\nimport { type IQueue } from \"aws-cdk-lib/aws-sqs\";\n\nimport type App from \"../../app\";\nimport { SQSQueue, type SQSQueueProps } from \"../../resources/aws/messaging/sqs\";\n\nexport interface ISQSProps {\n  queueType?: \"standard\" | \"fifo\";\n  visibilityTimeout?: number;\n  messageRetentionPeriod?: number;\n  receiveMessageWaitTime?: number;\n  maxMessageSize?: number;\n  deliveryDelay?: number;\n  deadLetterQueue?: {\n    enabled: boolean;\n    maxReceiveCount?: number;\n  };\n  encryption?: \"SSE_SQS\" | \"SSE_KMS\" | \"NONE\";\n  kmsKeyArn?: string;\n  contentBasedDeduplication?: boolean;\n  fifoThroughputLimit?: \"perQueue\" | \"perMessageGroupId\";\n  deduplicationScope?: \"queue\" | \"messageGroup\";\n  removalPolicy?: \"DESTROY\" | \"RETAIN\";\n}\n\n/**\n * Validates SQS props and logs warnings for misconfigured options.\n */\nfunction validateSQSProps(props: ISQSProps): void {\n  // Validate visibility timeout range (0-43200 seconds = 12 hours)\n  if (\n    props.visibilityTimeout !== undefined &&\n    (props.visibilityTimeout < 0 || props.visibilityTimeout > 43200)\n  ) {\n    throw new Error(\n      \"visibilityTimeout must be between 0 and 43200 seconds (12 hours)\"\n    );\n  }\n\n  // Validate message retention period (60-1209600 seconds = 1 minute to 14 days)\n  if (\n    props.messageRetentionPeriod !== undefined &&\n    (props.messageRetentionPeriod < 60 || props.messageRetentionPeriod > 1209600)\n  ) {\n    throw new Error(\n      \"messageRetentionPeriod must be between 60 and 1209600 seconds (1 minute to 14 days)\"\n    );\n  }\n\n  // Warn about FIFO-specific options on standard queues\n  if (props.queueType !== \"fifo\") {\n    if (props.contentBasedDeduplication !== undefined) {\n      console.warn(\n        \"[Fjall] Warning: 'contentBasedDeduplication' is only applicable to FIFO queues. \" +\n          \"This setting will be ignored for standard queues.\"\n      );\n    }\n    if (props.fifoThroughputLimit !== undefined) {\n      console.warn(\n        \"[Fjall] Warning: 'fifoThroughputLimit' is only applicable to FIFO queues. \" +\n          \"This setting will be ignored for standard queues.\"\n      );\n    }\n    if (props.deduplicationScope !== undefined) {\n      console.warn(\n        \"[Fjall] Warning: 'deduplicationScope' is only applicable to FIFO queues. \" +\n          \"This setting will be ignored for standard queues.\"\n      );\n    }\n  }\n\n  // Validate KMS encryption\n  if (props.kmsKeyArn && props.encryption !== \"SSE_KMS\") {\n    console.warn(\n      \"[Fjall] Warning: 'kmsKeyArn' provided but 'encryption' is not SSE_KMS. \" +\n        \"The KMS key will be ignored.\"\n    );\n  }\n}\n\n/**\n * SQS queue wrapper with grant methods and Fjall patterns.\n */\nexport class Queue extends SQSQueue {\n  constructor(scope: Construct, id: string, props: ISQSProps) {\n    const queueProps: SQSQueueProps = {\n      queueType: props.queueType,\n      visibilityTimeout: props.visibilityTimeout,\n      messageRetentionPeriod: props.messageRetentionPeriod,\n      receiveMessageWaitTime: props.receiveMessageWaitTime,\n      maxMessageSize: props.maxMessageSize,\n      deliveryDelay: props.deliveryDelay,\n      deadLetterQueue: props.deadLetterQueue,\n      encryption: props.encryption,\n      kmsKeyArn: props.kmsKeyArn,\n      contentBasedDeduplication: props.contentBasedDeduplication,\n      fifoThroughputLimit: props.fifoThroughputLimit,\n      deduplicationScope: props.deduplicationScope,\n      removalPolicy: props.removalPolicy\n    };\n    super(scope, id, queueProps);\n  }\n}\n\n/**\n * Factory for creating SQS queues.\n *\n * @example\n * // Standard queue with DLQ\n * const notifications = app.addQueue(QueueFactory.build(\"Notifications\", {\n *   queueType: \"standard\",\n *   deadLetterQueue: { enabled: true, maxReceiveCount: 3 }\n * }));\n *\n * @example\n * // FIFO queue for OpenNext revalidation\n * const revalidation = app.addQueue(QueueFactory.build(\"Revalidation\", {\n *   queueType: \"fifo\",\n *   visibilityTimeout: 300,\n *   contentBasedDeduplication: true\n * }));\n *\n * @example\n * // Grant permissions\n * revalidation.grantSend(serverFunction);\n * revalidation.grantConsume(revalidationFunction);\n */\nexport class QueueFactory {\n  /**\n   * Build an SQS queue factory function.\n   *\n   * @param id - Unique identifier for the queue\n   * @param props - SQS queue configuration properties\n   * @returns Factory function that creates the queue when invoked\n   */\n  static build(id: string, props: ISQSProps = {}) {\n    return (_app: App, scope: Construct): Queue => {\n      validateSQSProps(props);\n      return new Queue(scope, id, props);\n    };\n  }\n}\n\n// Re-export types for convenience\nexport type { SQSQueueProps } from \"../../resources/aws/messaging/sqs\";\n"]}

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

@@ -30,10 +30,11 @@ class S3Storage extends constructs_1.Construct {
             case "publicRead":
                 this.addPublicReadBucket(props);
                 break;
-            default:
+            default: {
                 // Exhaustiveness check
                 const _exhaustive = props;
                 throw new Error(`Unsupported S3 bucket type ${props.bucketType}`);
+            }
         }
     }
     addPrivateBucket(props) {
@@ -76,4 +77,4 @@ class S3Storage extends constructs_1.Construct {
     }
 }
 exports.S3Storage = S3Storage;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYi9wYXR0ZXJucy9hd3Mvc3RvcmFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyQ0FBdUM7QUFJdkMseURBS3FDO0FBZ0NyQyxNQUFhLGNBQWM7SUFDekIsTUFBTSxDQUFDLEtBQUssQ0FBcUIsRUFBVSxFQUFFLEtBQVE7UUFDbkQsT0FBTyxDQUFDLEdBQVEsRUFBRSxLQUFnQixFQUFFLEVBQUU7WUFDcEMsT0FBTyxJQUFJLFNBQVMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ3pDLENBQUMsQ0FBQztJQUNKLENBQUM7Q0FDRjtBQU5ELHdDQU1DO0FBRUQsTUFBYSxTQUFVLFNBQVEsc0JBQVM7SUFPdEMsWUFBWSxLQUFnQixFQUFFLEVBQVUsRUFBRSxLQUFlO1FBQ3ZELEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDakIsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUM7UUFDYixJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsVUFBVSxHQUFHLEtBQUssQ0FBQyxVQUFVLENBQUM7UUFFbkMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMxQixDQUFDO0lBRUQsV0FBVyxDQUFDLEtBQWU7UUFDekIsUUFBUSxLQUFLLENBQUMsVUFBVSxFQUFFLENBQUM7WUFDekIsS0FBSyxTQUFTO2dCQUNaLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDN0IsTUFBTTtZQUNSLEtBQUssU0FBUztnQkFDWixJQUFJLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzdCLE1BQU07WUFDUixLQUFLLFlBQVk7Z0JBQ2YsSUFBSSxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUNoQyxNQUFNO1lBQ1I7Z0JBQ0UsdUJBQXVCO2dCQUN2QixNQUFNLFdBQVcsR0FBVSxLQUFLLENBQUM7Z0JBQ2pDLE1BQU0sSUFBSSxLQUFLLENBQ2IsOEJBQStCLEtBQWEsQ0FBQyxVQUFVLEVBQUUsQ0FDMUQsQ0FBQztRQUNOLENBQUM7SUFDSCxDQUFDO0lBRU8sZ0JBQWdCLENBQUMsS0FBcUI7UUFDNUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLGtCQUFRLENBQUMsSUFBSSxFQUFFLEdBQUcsSUFBSSxDQUFDLEVBQUUsUUFBUSxFQUFFO1lBQ25ELGVBQWUsRUFBRSxLQUFLLENBQUMsZUFBZTtZQUN0QyxTQUFTLEVBQUUsS0FBSyxDQUFDLFNBQVM7WUFDMUIsVUFBVSxFQUFFLEtBQUssQ0FBQyxVQUFpQjtZQUNuQyxhQUFhLEVBQUUsS0FBSyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxTQUFTLEVBQUUsbUJBQW1CO1lBQzNFLGdCQUFnQixFQUFFLEtBQUssQ0FBQyxnQkFBZ0I7U0FDekMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLGdCQUFnQixDQUFDLEtBQXFCO1FBQzVDLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSx5QkFBZSxDQUFDLElBQUksRUFBRSxHQUFHLElBQUksQ0FBQyxFQUFFLFFBQVEsRUFBRTtZQUMxRCxlQUFlLEVBQUUsS0FBSyxDQUFDLGVBQWU7WUFDdEMsU0FBUyxFQUFFLEtBQUssQ0FBQyxTQUFTO1lBQzFCLFVBQVUsRUFBRSxLQUFLLENBQUMsVUFBaUI7WUFDbkMsb0JBQW9CLEVBQUUsS0FBSyxDQUFDLG9CQUFvQjtZQUNoRCxvQkFBb0IsRUFBRSxLQUFLLENBQUMsb0JBQW9CO1lBQ2hELElBQUksRUFBRSxLQUFLLENBQUMsSUFBVztTQUN4QixDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU8sbUJBQW1CLENBQUMsS0FBd0I7UUFDbEQsSUFBSSxDQUFDLE1BQU0sR0FBRyxJQUFJLDRCQUFrQixDQUFDLElBQUksRUFBRSxHQUFHLElBQUksQ0FBQyxFQUFFLFFBQVEsRUFBRTtZQUM3RCxlQUFlLEVBQUUsS0FBSyxDQUFDLGVBQWU7WUFDdEMsU0FBUyxFQUFFLEtBQUssQ0FBQyxTQUFTO1lBQzFCLFVBQVUsRUFBRSxLQUFLLENBQUMsVUFBaUI7U0FDcEMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELFNBQVM7UUFDUCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDckIsQ0FBQztJQUVELGFBQWE7UUFDWCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDO0lBQ2hDLENBQUM7SUFFRCxZQUFZO1FBQ1YsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsQ0FBQztJQUMvQixDQUFDO0lBRUQsYUFBYTtRQUNYLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0NBQ0Y7QUFoRkQsOEJBZ0ZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSBcImNvbnN0cnVjdHNcIjtcbmltcG9ydCB7IHR5cGUgSUJ1Y2tldCB9IGZyb20gXCJhd3MtY2RrLWxpYi9hd3MtczNcIjtcblxuaW1wb3J0IHR5cGUgQXBwIGZyb20gXCIuLi8uLi9hcHBcIjtcbmltcG9ydCB7XG4gIFMzQnVja2V0LFxuICBTM1dlYnNpdGVCdWNrZXQsXG4gIFMzUHVibGljUmVhZEJ1Y2tldCxcbiAgdHlwZSBCYWNrdXBWYXVsdFRpZXJcbn0gZnJvbSBcIi4uLy4uL3Jlc291cmNlcy9hd3Mvc3RvcmFnZVwiO1xuXG50eXBlIFMzQnVja2V0VHlwZSA9IFwicHJpdmF0ZVwiIHwgXCJ3ZWJzaXRlXCIgfCBcInB1YmxpY1JlYWRcIjtcblxudHlwZSBCYXNlUzNQcm9wcyA9IHtcbiAgYmFja3VwVmF1bHRUaWVyPzogQmFja3VwVmF1bHRUaWVyO1xuICB2ZXJzaW9uZWQ/OiBib29sZWFuO1xuICBlbmNyeXB0aW9uPzogXCJBRVMyNTZcIiB8IFwiS01TXCI7XG4gIGttc0tleUFybj86IHN0cmluZztcbn07XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJpdmF0ZVMzUHJvcHMgZXh0ZW5kcyBCYXNlUzNQcm9wcyB7XG4gIGJ1Y2tldFR5cGU6IFwicHJpdmF0ZVwiO1xuICBwdWJsaWNSZWFkQWNjZXNzPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXZWJzaXRlUzNQcm9wcyBleHRlbmRzIEJhc2VTM1Byb3BzIHtcbiAgYnVja2V0VHlwZTogXCJ3ZWJzaXRlXCI7XG4gIHdlYnNpdGVJbmRleERvY3VtZW50Pzogc3RyaW5nO1xuICB3ZWJzaXRlRXJyb3JEb2N1bWVudD86IHN0cmluZztcbiAgY29ycz86IEFycmF5PHtcbiAgICBhbGxvd2VkT3JpZ2luczogc3RyaW5nW107XG4gICAgYWxsb3dlZE1ldGhvZHM6IHN0cmluZ1tdO1xuICB9Pjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQdWJsaWNSZWFkUzNQcm9wcyBleHRlbmRzIEJhc2VTM1Byb3BzIHtcbiAgYnVja2V0VHlwZTogXCJwdWJsaWNSZWFkXCI7XG59XG5cbmV4cG9ydCB0eXBlIElTM1Byb3BzID0gUHJpdmF0ZVMzUHJvcHMgfCBXZWJzaXRlUzNQcm9wcyB8IFB1YmxpY1JlYWRTM1Byb3BzO1xuXG5leHBvcnQgY2xhc3MgU3RvcmFnZUZhY3Rvcnkge1xuICBzdGF0aWMgYnVpbGQ8VCBleHRlbmRzIElTM1Byb3BzPihpZDogc3RyaW5nLCBwcm9wczogVCkge1xuICAgIHJldHVybiAoYXBwOiBBcHAsIHNjb3BlOiBDb25zdHJ1Y3QpID0+IHtcbiAgICAgIHJldHVybiBuZXcgUzNTdG9yYWdlKHNjb3BlLCBpZCwgcHJvcHMpO1xuICAgIH07XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIFMzU3RvcmFnZSBleHRlbmRzIENvbnN0cnVjdCB7XG4gIHB1YmxpYyBpZDogc3RyaW5nO1xuICBwdWJsaWMgc2NvcGU6IENvbnN0cnVjdDtcblxuICBwcml2YXRlIGJ1Y2tldDogUzNCdWNrZXQgfCBTM1dlYnNpdGVCdWNrZXQgfCBTM1B1YmxpY1JlYWRCdWNrZXQ7XG4gIHByaXZhdGUgYnVja2V0VHlwZTogUzNCdWNrZXRUeXBlO1xuXG4gIGNvbnN0cnVjdG9yKHNjb3BlOiBDb25zdHJ1Y3QsIGlkOiBzdHJpbmcsIHByb3BzOiBJUzNQcm9wcykge1xuICAgIHN1cGVyKHNjb3BlLCBpZCk7XG4gICAgdGhpcy5pZCA9IGlkO1xuICAgIHRoaXMuc2NvcGUgPSBzY29wZTtcbiAgICB0aGlzLmJ1Y2tldFR5cGUgPSBwcm9wcy5idWNrZXRUeXBlO1xuXG4gICAgdGhpcy5hZGRTM0J1Y2tldChwcm9wcyk7XG4gIH1cblxuICBhZGRTM0J1Y2tldChwcm9wczogSVMzUHJvcHMpIHtcbiAgICBzd2l0Y2ggKHByb3BzLmJ1Y2tldFR5cGUpIHtcbiAgICAgIGNhc2UgXCJwcml2YXRlXCI6XG4gICAgICAgIHRoaXMuYWRkUHJpdmF0ZUJ1Y2tldChwcm9wcyk7XG4gICAgICAgIGJyZWFrO1xuICAgICAgY2FzZSBcIndlYnNpdGVcIjpcbiAgICAgICAgdGhpcy5hZGRXZWJzaXRlQnVja2V0KHByb3BzKTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlIFwicHVibGljUmVhZFwiOlxuICAgICAgICB0aGlzLmFkZFB1YmxpY1JlYWRCdWNrZXQocHJvcHMpO1xuICAgICAgICBicmVhaztcbiAgICAgIGRlZmF1bHQ6XG4gICAgICAgIC8vIEV4aGF1c3RpdmVuZXNzIGNoZWNrXG4gICAgICAgIGNvbnN0IF9leGhhdXN0aXZlOiBuZXZlciA9IHByb3BzO1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoXG4gICAgICAgICAgYFVuc3VwcG9ydGVkIFMzIGJ1Y2tldCB0eXBlICR7KHByb3BzIGFzIGFueSkuYnVja2V0VHlwZX1gXG4gICAgICAgICk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBhZGRQcml2YXRlQnVja2V0KHByb3BzOiBQcml2YXRlUzNQcm9wcykge1xuICAgIHRoaXMuYnVja2V0ID0gbmV3IFMzQnVja2V0KHRoaXMsIGAke3RoaXMuaWR9QnVja2V0YCwge1xuICAgICAgYmFja3VwVmF1bHRUaWVyOiBwcm9wcy5iYWNrdXBWYXVsdFRpZXIsXG4gICAgICB2ZXJzaW9uZWQ6IHByb3BzLnZlcnNpb25lZCxcbiAgICAgIGVuY3J5cHRpb246IHByb3BzLmVuY3J5cHRpb24gYXMgYW55LFxuICAgICAgZW5jcnlwdGlvbktleTogcHJvcHMua21zS2V5QXJuID8gdW5kZWZpbmVkIDogdW5kZWZpbmVkLCAvLyBLTVMga2V5IGhhbmRsaW5nXG4gICAgICBwdWJsaWNSZWFkQWNjZXNzOiBwcm9wcy5wdWJsaWNSZWFkQWNjZXNzXG4gICAgfSk7XG4gIH1cblxuICBwcml2YXRlIGFkZFdlYnNpdGVCdWNrZXQocHJvcHM6IFdlYnNpdGVTM1Byb3BzKSB7XG4gICAgdGhpcy5idWNrZXQgPSBuZXcgUzNXZWJzaXRlQnVja2V0KHRoaXMsIGAke3RoaXMuaWR9QnVja2V0YCwge1xuICAgICAgYmFja3VwVmF1bHRUaWVyOiBwcm9wcy5iYWNrdXBWYXVsdFRpZXIsXG4gICAgICB2ZXJzaW9uZWQ6IHByb3BzLnZlcnNpb25lZCxcbiAgICAgIGVuY3J5cHRpb246IHByb3BzLmVuY3J5cHRpb24gYXMgYW55LFxuICAgICAgd2Vic2l0ZUluZGV4RG9jdW1lbnQ6IHByb3BzLndlYnNpdGVJbmRleERvY3VtZW50LFxuICAgICAgd2Vic2l0ZUVycm9yRG9jdW1lbnQ6IHByb3BzLndlYnNpdGVFcnJvckRvY3VtZW50LFxuICAgICAgY29yczogcHJvcHMuY29ycyBhcyBhbnlcbiAgICB9KTtcbiAgfVxuXG4gIHByaXZhdGUgYWRkUHVibGljUmVhZEJ1Y2tldChwcm9wczogUHVibGljUmVhZFMzUHJvcHMpIHtcbiAgICB0aGlzLmJ1Y2tldCA9IG5ldyBTM1B1YmxpY1JlYWRCdWNrZXQodGhpcywgYCR7dGhpcy5pZH1CdWNrZXRgLCB7XG4gICAgICBiYWNrdXBWYXVsdFRpZXI6IHByb3BzLmJhY2t1cFZhdWx0VGllcixcbiAgICAgIHZlcnNpb25lZDogcHJvcHMudmVyc2lvbmVkLFxuICAgICAgZW5jcnlwdGlvbjogcHJvcHMuZW5jcnlwdGlvbiBhcyBhbnlcbiAgICB9KTtcbiAgfVxuXG4gIGdldEJ1Y2tldCgpOiBJQnVja2V0IHtcbiAgICByZXR1cm4gdGhpcy5idWNrZXQ7XG4gIH1cblxuICBnZXRCdWNrZXROYW1lKCk6IHN0cmluZyB7XG4gICAgcmV0dXJuIHRoaXMuYnVja2V0LmJ1Y2tldE5hbWU7XG4gIH1cblxuICBnZXRCdWNrZXRBcm4oKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGhpcy5idWNrZXQuYnVja2V0QXJuO1xuICB9XG5cbiAgZ2V0QnVja2V0VHlwZSgpOiBTM0J1Y2tldFR5cGUge1xuICAgIHJldHVybiB0aGlzLmJ1Y2tldFR5cGU7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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