terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/alb/application-listener-rule.js

@@ -0,0 +1,220 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationListenerRule = exports.ContentType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/application-listener-rule.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const constructs_1 = require("constructs");
+const application_listener_action_1 = require("./application-listener-action");
+/**
+ * The content type for a fixed response
+ * @deprecated superseded by `FixedResponseOptions`.
+ */
+var ContentType;
+(function (ContentType) {
+    ContentType["TEXT_PLAIN"] = "text/plain";
+    ContentType["TEXT_CSS"] = "text/css";
+    ContentType["TEXT_HTML"] = "text/html";
+    ContentType["APPLICATION_JAVASCRIPT"] = "application/javascript";
+    ContentType["APPLICATION_JSON"] = "application/json";
+})(ContentType || (exports.ContentType = ContentType = {}));
+/**
+ * Define a new listener rule
+ */
+class ApplicationListenerRule extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.legacyConditions = {};
+        this.conditions = props.conditions || [];
+        const hasPathPatterns = props.pathPatterns || props.pathPattern;
+        if (this.conditions.length === 0 && !props.hostHeader && !hasPathPatterns) {
+            throw new Error("At least one of 'conditions', 'hostHeader', 'pathPattern' or 'pathPatterns' is required when defining a load balancing rule.");
+        }
+        const possibleActions = [
+            "action",
+            "targetGroups",
+            "fixedResponse",
+            "redirectResponse",
+        ];
+        const providedActions = possibleActions.filter((action) => props[action] !== undefined);
+        if (providedActions.length > 1) {
+            throw new Error(`'${providedActions}' specified together, specify only one`);
+        }
+        if (!cdktf_1.Token.isUnresolved(props.priority) && props.priority <= 0) {
+            throw new Error("Priority must have value greater than or equal to 1");
+        }
+        this.listener = props.listener;
+        const resource = new provider_aws_1.lbListenerRule.LbListenerRule(this, "Resource", {
+            listenerArn: props.listener.listenerArn,
+            priority: props.priority,
+            condition: cdktf_1.Lazy.anyValue({ produce: () => this.renderConditions() }),
+            action: cdktf_1.Lazy.anyValue({
+                produce: () => this.action
+                    ? this.action
+                        .renderRuleActions()
+                        .map(provider_aws_1.lbListenerRule.lbListenerRuleActionToTerraform)
+                    : [],
+            }),
+        });
+        if (props.hostHeader) {
+            this.setCondition("host_header", [props.hostHeader]);
+        }
+        if (hasPathPatterns) {
+            if (props.pathPattern && props.pathPatterns) {
+                throw new Error("Both `pathPatterns` and `pathPattern` are specified, specify only one");
+            }
+            const pathPattern = props.pathPattern
+                ? [props.pathPattern]
+                : props.pathPatterns;
+            this.setCondition("path_pattern", pathPattern);
+        }
+        if (props.action) {
+            this.configureAction(props.action);
+        }
+        if (props.targetGroups) {
+            this.configureAction(application_listener_action_1.ListenerAction.forward(props.targetGroups));
+        }
+        if (props.fixedResponse) {
+            this.addFixedResponse(props.fixedResponse);
+        }
+        else if (props.redirectResponse) {
+            this.addRedirectResponse(props.redirectResponse);
+        }
+        this.listenerRuleArn = resource.arn;
+        this.node.addValidation({ validate: () => this.validateListenerRule() });
+    }
+    /**
+     * Add a non-standard condition to this rule
+     *
+     * If the condition conflicts with an already set condition, it will be overwritten by the one you specified.
+     *
+     * @deprecated use `addCondition` instead.
+     */
+    setCondition(field, values) {
+        if (values === undefined) {
+            delete this.legacyConditions[field];
+            return;
+        }
+        this.legacyConditions[field] = values;
+    }
+    /**
+     * Add a non-standard condition to this rule
+     */
+    addCondition(condition) {
+        this.conditions.push(condition);
+    }
+    /**
+     * Configure the action to perform for this rule
+     */
+    configureAction(action) {
+        // It might make sense to 'throw' here.
+        //
+        // However, programs may already exist out there which configured an action twice,
+        // in which case the second action accidentally overwrite the initial action, and in some
+        // way ended up with a program that did what the author intended. If we were to add throw now,
+        // the previously working program would be broken.
+        //
+        // Instead, signal this through a warning.
+        // @deprecate: upon the next major version bump, replace this with a `throw`
+        if (this.action) {
+            // "@aws-cdk/aws-elbv2:albListnerRuleDefaultActionReplaced",
+            cdktf_1.Annotations.of(this).addWarning("An Action already existed on this ListenerRule and was replaced. Configure exactly one default Action.");
+        }
+        action.bind(this, this.listener, this);
+        this.action = action;
+    }
+    /**
+     * Add a TargetGroup to load balance to
+     *
+     * @deprecated Use configureAction instead
+     */
+    addTargetGroup(targetGroup) {
+        this.configureAction(application_listener_action_1.ListenerAction.forward([targetGroup]));
+    }
+    /**
+     * Add a fixed response
+     *
+     * @deprecated Use configureAction instead
+     */
+    addFixedResponse(fixedResponse) {
+        validateFixedResponse(fixedResponse);
+        this.configureAction(application_listener_action_1.ListenerAction.fixedResponse(cdktf_1.Token.asNumber(fixedResponse.statusCode), {
+            contentType: fixedResponse.contentType ?? ContentType.TEXT_PLAIN,
+            messageBody: fixedResponse.messageBody,
+        }));
+    }
+    /**
+     * Add a redirect response
+     *
+     * @deprecated Use configureAction instead
+     */
+    addRedirectResponse(redirectResponse) {
+        validateRedirectResponse(redirectResponse);
+        this.configureAction(application_listener_action_1.ListenerAction.redirect({
+            host: redirectResponse.host,
+            path: redirectResponse.path,
+            permanent: redirectResponse.statusCode === "HTTP_301",
+            port: redirectResponse.port,
+            protocol: redirectResponse.protocol,
+            query: redirectResponse.query,
+        }));
+    }
+    /**
+     * Validate the rule
+     */
+    validateListenerRule() {
+        if (this.action === undefined) {
+            return ["Listener rule needs at least one action"];
+        }
+        const legacyConditionFields = Object.keys(this.legacyConditions);
+        if (legacyConditionFields.length === 0 && this.conditions.length === 0) {
+            return ["Listener rule needs at least one condition"];
+        }
+        return [];
+    }
+    /**
+     * Render the conditions for this rule
+     */
+    renderConditions() {
+        const legacyConditions = Object.entries(this.legacyConditions).map(([field, values]) => {
+            return { [field]: { values } };
+        });
+        const conditions = this.conditions.map((condition) => condition.renderRawCondition());
+        return [...legacyConditions, ...conditions];
+    }
+}
+exports.ApplicationListenerRule = ApplicationListenerRule;
+_a = JSII_RTTI_SYMBOL_1;
+ApplicationListenerRule[_a] = { fqn: "terraconstructs.aws.compute.ApplicationListenerRule", version: "0.0.12" };
+/**
+ * Validate the status code and message body of a fixed response
+ * @internal
+ * @deprecated
+ */
+function validateFixedResponse(fixedResponse) {
+    if (fixedResponse.statusCode &&
+        !/^(2|4|5)\d\d$/.test(fixedResponse.statusCode)) {
+        throw new Error("`statusCode` must be 2XX, 4XX or 5XX.");
+    }
+    if (fixedResponse.messageBody && fixedResponse.messageBody.length > 1024) {
+        throw new Error("`messageBody` cannot have more than 1024 characters.");
+    }
+}
+/**
+ * Validate the status code and message body of a redirect response
+ * @internal
+ * @deprecated
+ */
+function validateRedirectResponse(redirectResponse) {
+    if (redirectResponse.protocol &&
+        !/^(HTTPS?|#\{protocol\})$/i.test(redirectResponse.protocol)) {
+        throw new Error("`protocol` must be HTTP, HTTPS, or #{protocol}.");
+    }
+    if (!redirectResponse.statusCode ||
+        !/^HTTP_30[12]$/.test(redirectResponse.statusCode)) {
+        throw new Error("`statusCode` must be HTTP_301 or HTTP_302.");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application-listener-rule.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/application-listener-rule.ts"],"names":[],"mappings":";;;;;AAAA,oIAAoI;AAEpI,sDAAuE;AACvE,iCAAiD;AACjD,2CAAuC;AAEvC,+EAA+D;AA+G/D;;;GAGG;AACH,IAAY,WAMX;AAND,WAAY,WAAW;IACrB,wCAAyB,CAAA;IACzB,oCAAqB,CAAA;IACrB,sCAAuB,CAAA;IACvB,gEAAiD,CAAA;IACjD,oDAAqC,CAAA;AACvC,CAAC,EANW,WAAW,2BAAX,WAAW,QAMtB;AAwED;;GAEG;AACH,MAAa,uBAAwB,SAAQ,sBAAS;IAYpD,YACE,KAAgB,EAChB,EAAU,EACV,KAAmC;QAEnC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAVF,qBAAgB,GAAgC,EAAE,CAAC;QAYlE,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,EAAE,CAAC;QAEzC,MAAM,eAAe,GAAG,KAAK,CAAC,YAAY,IAAI,KAAK,CAAC,WAAW,CAAC;QAChE,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1E,MAAM,IAAI,KAAK,CACb,8HAA8H,CAC/H,CAAC;QACJ,CAAC;QAED,MAAM,eAAe,GAA8C;YACjE,QAAQ;YACR,cAAc;YACd,eAAe;YACf,kBAAkB;SACnB,CAAC;QACF,MAAM,eAAe,GAAG,eAAe,CAAC,MAAM,CAC5C,CAAC,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,SAAS,CACxC,CAAC;QACF,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CACb,IAAI,eAAe,wCAAwC,CAC5D,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAE/B,MAAM,QAAQ,GAAG,IAAI,6BAAc,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE;YACnE,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,WAAW;YACvC,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,SAAS,EAAE,YAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE,EAAE,CAAC;YACpE,MAAM,EAAE,YAAI,CAAC,QAAQ,CAAC;gBACpB,OAAO,EAAE,GAAG,EAAE,CACZ,IAAI,CAAC,MAAM;oBACT,CAAC,CAAC,IAAI,CAAC,MAAM;yBACR,iBAAiB,EAAE;yBACnB,GAAG,CAAC,6BAAc,CAAC,+BAA+B,CAAC;oBACxD,CAAC,CAAC,EAAE;aACT,CAAC;SACH,CAAC,CAAC;QAEH,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;QACvD,CAAC;QAED,IAAI,eAAe,EAAE,CAAC;YACpB,IAAI,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;gBAC5C,MAAM,IAAI,KAAK,CACb,uEAAuE,CACxE,CAAC;YACJ,CAAC;YACD,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW;gBACnC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC;gBACrB,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC;YACvB,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,WAAW,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACvB,IAAI,CAAC,eAAe,CAAC,4CAAc,CAAC,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;QACnE,CAAC;QAED,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;QAC7C,CAAC;aAAM,IAAI,KAAK,CAAC,gBAAgB,EAAE,CAAC;YAClC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACnD,CAAC;QAED,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,GAAG,CAAC;QAEpC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED;;;;;;OAMG;IACI,YAAY,CAAC,KAAa,EAAE,MAA4B;QAC7D,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YACpC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC;IACxC,CAAC;IAED;;OAEG;IACI,YAAY,CAAC,SAA4B;QAC9C,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,eAAe,CAAC,MAAsB;QAC3C,uCAAuC;QACvC,EAAE;QACF,kFAAkF;QAClF,yFAAyF;QACzF,8FAA8F;QAC9F,kDAAkD;QAClD,EAAE;QACF,0CAA0C;QAC1C,4EAA4E;QAC5E,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,4DAA4D;YAC5D,mBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,wGAAwG,CACzG,CAAC;QACJ,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,WAAoC;QACxD,IAAI,CAAC,eAAe,CAAC,4CAAc,CAAC,OAAO,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,aAA4B;QAClD,qBAAqB,CAAC,aAAa,CAAC,CAAC;QAErC,IAAI,CAAC,eAAe,CAClB,4CAAc,CAAC,aAAa,CAAC,aAAK,CAAC,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE;YACrE,WAAW,EAAE,aAAa,CAAC,WAAW,IAAI,WAAW,CAAC,UAAU;YAChE,WAAW,EAAE,aAAa,CAAC,WAAW;SACvC,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,mBAAmB,CAAC,gBAAkC;QAC3D,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QAE3C,IAAI,CAAC,eAAe,CAClB,4CAAc,CAAC,QAAQ,CAAC;YACtB,IAAI,EAAE,gBAAgB,CAAC,IAAI;YAC3B,IAAI,EAAE,gBAAgB,CAAC,IAAI;YAC3B,SAAS,EAAE,gBAAgB,CAAC,UAAU,KAAK,UAAU;YACrD,IAAI,EAAE,gBAAgB,CAAC,IAAI;YAC3B,QAAQ,EAAE,gBAAgB,CAAC,QAAQ;YACnC,KAAK,EAAE,gBAAgB,CAAC,KAAK;SAC9B,CAAC,CACH,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,OAAO,CAAC,yCAAyC,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,qBAAqB,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACjE,IAAI,qBAAqB,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvE,OAAO,CAAC,4CAA4C,CAAC,CAAC;QACxD,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAChE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE;YAClB,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;QACjC,CAAC,CACF,CAAC;QACF,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CACnD,SAAS,CAAC,kBAAkB,EAAE,CAC/B,CAAC;QAEF,OAAO,CAAC,GAAG,gBAAgB,EAAE,GAAG,UAAU,CAAC,CAAC;IAC9C,CAAC;;AA5NH,0DA6NC;;;AAED;;;;GAIG;AACH,SAAS,qBAAqB,CAAC,aAA4B;IACzD,IACE,aAAa,CAAC,UAAU;QACxB,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,EAC/C,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,aAAa,CAAC,WAAW,IAAI,aAAa,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC;QACzE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,wBAAwB,CAAC,gBAAkC;IAClE,IACE,gBAAgB,CAAC,QAAQ;QACzB,CAAC,2BAA2B,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAC5D,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;IAED,IACE,CAAC,gBAAgB,CAAC,UAAU;QAC5B,CAAC,eAAe,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,EAClD,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAChE,CAAC;AACH,CAAC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/application-listener-rule.ts\n\nimport { lbListenerRule as tfListenerRule } from \"@cdktf/provider-aws\";\nimport { Annotations, Token, Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { IApplicationListener } from \"./application-listener\";\nimport { ListenerAction } from \"./application-listener-action\";\nimport { IApplicationTargetGroup } from \"./application-target-group\";\nimport { ListenerCondition } from \"./conditions\";\nimport { IListenerAction } from \"../lb-shared/listener-action\";\n\n/**\n * Basic properties for defining a rule on a listener\n */\nexport interface BaseApplicationListenerRuleProps {\n  /**\n   * Priority of the rule\n   *\n   * The rule with the lowest priority will be used for every request.\n   *\n   * Priorities must be unique.\n   */\n  readonly priority: number;\n\n  /**\n   * Target groups to forward requests to.\n   *\n   * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.\n   *\n   * Implies a `forward` action.\n   *\n   * @default - No target groups.\n   */\n  readonly targetGroups?: IApplicationTargetGroup[];\n\n  /**\n   * Action to perform when requests are received\n   *\n   * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.\n   *\n   * @default - No action\n   */\n  readonly action?: ListenerAction;\n\n  /**\n   * Fixed response to return.\n   *\n   * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.\n   *\n   * @default - No fixed response.\n   * @deprecated Use `action` instead.\n   */\n  readonly fixedResponse?: FixedResponse;\n\n  /**\n   * Redirect response to return.\n   *\n   * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.\n   *\n   * @default - No redirect response.\n   * @deprecated Use `action` instead.\n   */\n  readonly redirectResponse?: RedirectResponse;\n\n  /**\n   * Rule applies if matches the conditions.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html\n   *\n   * @default - No conditions.\n   */\n  readonly conditions?: ListenerCondition[];\n\n  /**\n   * Rule applies if the requested host matches the indicated host\n   *\n   * May contain up to three '*' wildcards.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#host-conditions\n   *\n   * @default - No host condition.\n   * @deprecated Use `conditions` instead.\n   */\n  readonly hostHeader?: string;\n\n  /**\n   * Rule applies if the requested path matches the given path pattern\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions\n   * @default - No path condition.\n   * @deprecated Use `conditions` instead.\n   */\n  readonly pathPattern?: string;\n\n  /**\n   * Rule applies if the requested path matches any of the given patterns.\n   *\n   * Paths may contain up to three '*' wildcards.\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions\n   * @default - No path conditions.\n   * @deprecated Use `conditions` instead.\n   */\n  readonly pathPatterns?: string[];\n}\n\n/**\n * Properties for defining a listener rule\n */\nexport interface ApplicationListenerRuleProps\n  extends BaseApplicationListenerRuleProps {\n  /**\n   * The listener to attach the rule to\n   */\n  readonly listener: IApplicationListener;\n}\n\n/**\n * The content type for a fixed response\n * @deprecated superseded by `FixedResponseOptions`.\n */\nexport enum ContentType {\n  TEXT_PLAIN = \"text/plain\",\n  TEXT_CSS = \"text/css\",\n  TEXT_HTML = \"text/html\",\n  APPLICATION_JAVASCRIPT = \"application/javascript\",\n  APPLICATION_JSON = \"application/json\",\n}\n\n/**\n * A fixed response\n * @deprecated superseded by `ListenerAction.fixedResponse()`.\n */\nexport interface FixedResponse {\n  /**\n   * The HTTP response code (2XX, 4XX or 5XX)\n   */\n  readonly statusCode: string;\n\n  /**\n   * The content type\n   *\n   * @default text/plain\n   */\n  readonly contentType?: ContentType;\n\n  /**\n   * The message\n   *\n   * @default no message\n   */\n  readonly messageBody?: string;\n}\n\n/**\n * A redirect response\n * @deprecated superseded by `ListenerAction.redirect()`.\n */\nexport interface RedirectResponse {\n  /**\n   * The hostname. This component is not percent-encoded. The hostname can contain #{host}.\n   *\n   * @default origin host of request\n   */\n  readonly host?: string;\n  /**\n   * The absolute path, starting with the leading \"/\". This component is not percent-encoded.\n   * The path can contain #{host}, #{path}, and #{port}.\n   *\n   * @default origin path of request\n   */\n  readonly path?: string;\n  /**\n   * The port. You can specify a value from 1 to 65535 or #{port}.\n   *\n   * @default origin port of request\n   */\n  readonly port?: string;\n  /**\n   * The protocol. You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP to HTTP,\n   * HTTP to HTTPS, and HTTPS to HTTPS. You cannot redirect HTTPS to HTTP.\n   *\n   * @default origin protocol of request\n   */\n  readonly protocol?: string;\n  /**\n   * The query parameters, URL-encoded when necessary, but not percent-encoded.\n   * Do not include the leading \"?\", as it is automatically added.\n   * You can specify any of the reserved keywords.\n   *\n   * @default origin query string of request\n   */\n  readonly query?: string;\n  /**\n   * The HTTP redirect code (HTTP_301 or HTTP_302)\n   */\n  readonly statusCode: string;\n}\n\n/**\n * Define a new listener rule\n */\nexport class ApplicationListenerRule extends Construct {\n  /**\n   * The ARN of this rule\n   */\n  public readonly listenerRuleArn: string;\n\n  private readonly conditions: ListenerCondition[];\n  private readonly legacyConditions: { [key: string]: string[] } = {};\n\n  private readonly listener: IApplicationListener;\n  private action?: IListenerAction;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: ApplicationListenerRuleProps,\n  ) {\n    super(scope, id);\n\n    this.conditions = props.conditions || [];\n\n    const hasPathPatterns = props.pathPatterns || props.pathPattern;\n    if (this.conditions.length === 0 && !props.hostHeader && !hasPathPatterns) {\n      throw new Error(\n        \"At least one of 'conditions', 'hostHeader', 'pathPattern' or 'pathPatterns' is required when defining a load balancing rule.\",\n      );\n    }\n\n    const possibleActions: Array<keyof ApplicationListenerRuleProps> = [\n      \"action\",\n      \"targetGroups\",\n      \"fixedResponse\",\n      \"redirectResponse\",\n    ];\n    const providedActions = possibleActions.filter(\n      (action) => props[action] !== undefined,\n    );\n    if (providedActions.length > 1) {\n      throw new Error(\n        `'${providedActions}' specified together, specify only one`,\n      );\n    }\n\n    if (!Token.isUnresolved(props.priority) && props.priority <= 0) {\n      throw new Error(\"Priority must have value greater than or equal to 1\");\n    }\n\n    this.listener = props.listener;\n\n    const resource = new tfListenerRule.LbListenerRule(this, \"Resource\", {\n      listenerArn: props.listener.listenerArn,\n      priority: props.priority,\n      condition: Lazy.anyValue({ produce: () => this.renderConditions() }),\n      action: Lazy.anyValue({\n        produce: () =>\n          this.action\n            ? this.action\n                .renderRuleActions()\n                .map(tfListenerRule.lbListenerRuleActionToTerraform)\n            : [],\n      }),\n    });\n\n    if (props.hostHeader) {\n      this.setCondition(\"host_header\", [props.hostHeader]);\n    }\n\n    if (hasPathPatterns) {\n      if (props.pathPattern && props.pathPatterns) {\n        throw new Error(\n          \"Both `pathPatterns` and `pathPattern` are specified, specify only one\",\n        );\n      }\n      const pathPattern = props.pathPattern\n        ? [props.pathPattern]\n        : props.pathPatterns;\n      this.setCondition(\"path_pattern\", pathPattern);\n    }\n\n    if (props.action) {\n      this.configureAction(props.action);\n    }\n\n    if (props.targetGroups) {\n      this.configureAction(ListenerAction.forward(props.targetGroups));\n    }\n\n    if (props.fixedResponse) {\n      this.addFixedResponse(props.fixedResponse);\n    } else if (props.redirectResponse) {\n      this.addRedirectResponse(props.redirectResponse);\n    }\n\n    this.listenerRuleArn = resource.arn;\n\n    this.node.addValidation({ validate: () => this.validateListenerRule() });\n  }\n\n  /**\n   * Add a non-standard condition to this rule\n   *\n   * If the condition conflicts with an already set condition, it will be overwritten by the one you specified.\n   *\n   * @deprecated use `addCondition` instead.\n   */\n  public setCondition(field: string, values: string[] | undefined) {\n    if (values === undefined) {\n      delete this.legacyConditions[field];\n      return;\n    }\n\n    this.legacyConditions[field] = values;\n  }\n\n  /**\n   * Add a non-standard condition to this rule\n   */\n  public addCondition(condition: ListenerCondition) {\n    this.conditions.push(condition);\n  }\n\n  /**\n   * Configure the action to perform for this rule\n   */\n  public configureAction(action: ListenerAction) {\n    // It might make sense to 'throw' here.\n    //\n    // However, programs may already exist out there which configured an action twice,\n    // in which case the second action accidentally overwrite the initial action, and in some\n    // way ended up with a program that did what the author intended. If we were to add throw now,\n    // the previously working program would be broken.\n    //\n    // Instead, signal this through a warning.\n    // @deprecate: upon the next major version bump, replace this with a `throw`\n    if (this.action) {\n      // \"@aws-cdk/aws-elbv2:albListnerRuleDefaultActionReplaced\",\n      Annotations.of(this).addWarning(\n        \"An Action already existed on this ListenerRule and was replaced. Configure exactly one default Action.\",\n      );\n    }\n\n    action.bind(this, this.listener, this);\n    this.action = action;\n  }\n\n  /**\n   * Add a TargetGroup to load balance to\n   *\n   * @deprecated Use configureAction instead\n   */\n  public addTargetGroup(targetGroup: IApplicationTargetGroup) {\n    this.configureAction(ListenerAction.forward([targetGroup]));\n  }\n\n  /**\n   * Add a fixed response\n   *\n   * @deprecated Use configureAction instead\n   */\n  public addFixedResponse(fixedResponse: FixedResponse) {\n    validateFixedResponse(fixedResponse);\n\n    this.configureAction(\n      ListenerAction.fixedResponse(Token.asNumber(fixedResponse.statusCode), {\n        contentType: fixedResponse.contentType ?? ContentType.TEXT_PLAIN,\n        messageBody: fixedResponse.messageBody,\n      }),\n    );\n  }\n\n  /**\n   * Add a redirect response\n   *\n   * @deprecated Use configureAction instead\n   */\n  public addRedirectResponse(redirectResponse: RedirectResponse) {\n    validateRedirectResponse(redirectResponse);\n\n    this.configureAction(\n      ListenerAction.redirect({\n        host: redirectResponse.host,\n        path: redirectResponse.path,\n        permanent: redirectResponse.statusCode === \"HTTP_301\",\n        port: redirectResponse.port,\n        protocol: redirectResponse.protocol,\n        query: redirectResponse.query,\n      }),\n    );\n  }\n\n  /**\n   * Validate the rule\n   */\n  private validateListenerRule() {\n    if (this.action === undefined) {\n      return [\"Listener rule needs at least one action\"];\n    }\n\n    const legacyConditionFields = Object.keys(this.legacyConditions);\n    if (legacyConditionFields.length === 0 && this.conditions.length === 0) {\n      return [\"Listener rule needs at least one condition\"];\n    }\n\n    return [];\n  }\n\n  /**\n   * Render the conditions for this rule\n   */\n  private renderConditions(): any {\n    const legacyConditions = Object.entries(this.legacyConditions).map(\n      ([field, values]) => {\n        return { [field]: { values } };\n      },\n    );\n    const conditions = this.conditions.map((condition) =>\n      condition.renderRawCondition(),\n    );\n\n    return [...legacyConditions, ...conditions];\n  }\n}\n\n/**\n * Validate the status code and message body of a fixed response\n * @internal\n * @deprecated\n */\nfunction validateFixedResponse(fixedResponse: FixedResponse) {\n  if (\n    fixedResponse.statusCode &&\n    !/^(2|4|5)\\d\\d$/.test(fixedResponse.statusCode)\n  ) {\n    throw new Error(\"`statusCode` must be 2XX, 4XX or 5XX.\");\n  }\n\n  if (fixedResponse.messageBody && fixedResponse.messageBody.length > 1024) {\n    throw new Error(\"`messageBody` cannot have more than 1024 characters.\");\n  }\n}\n\n/**\n * Validate the status code and message body of a redirect response\n * @internal\n * @deprecated\n */\nfunction validateRedirectResponse(redirectResponse: RedirectResponse) {\n  if (\n    redirectResponse.protocol &&\n    !/^(HTTPS?|#\\{protocol\\})$/i.test(redirectResponse.protocol)\n  ) {\n    throw new Error(\"`protocol` must be HTTP, HTTPS, or #{protocol}.\");\n  }\n\n  if (\n    !redirectResponse.statusCode ||\n    !/^HTTP_30[12]$/.test(redirectResponse.statusCode)\n  ) {\n    throw new Error(\"`statusCode` must be HTTP_301 or HTTP_302.\");\n  }\n}\n"]}