terraconstructs 0.0.11 → 0.0.12

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

@@ -0,0 +1,281 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthenticatedAction = exports.ListenerAction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktf_1 = require("cdktf");
+const port_1 = require("../port");
+/**
+ * What to do when a client makes a request to a listener
+ *
+ * Some actions can be combined with other ones (specifically,
+ * you can perform authentication before serving the request).
+ *
+ * Multiple actions form a linked chain; the chain must always terminate in a
+ * *(weighted)forward*, *fixedResponse* or *redirect* action.
+ *
+ * If an action supports chaining, the next action can be indicated
+ * by passing it in the `next` property.
+ *
+ * (Called `ListenerAction` instead of the more strictly correct
+ * `ListenerAction` because this is the class most users interact
+ * with, and we want to make it not too visually overwhelming).
+ */
+class ListenerAction {
+    /**
+     * Authenticate using an identity provider (IdP) that is compliant with OpenID Connect (OIDC)
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/listener-authenticate-users.html#oidc-requirements
+     */
+    static authenticateOidc(options) {
+        return new AuthenticateOidcAction(options);
+    }
+    /**
+     * Forward to one or more Target Groups
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#forward-actions
+     */
+    static forward(targetGroups, options = {}) {
+        if (targetGroups.length === 0) {
+            throw new Error("Need at least one targetGroup in a ListenerAction.forward()");
+        }
+        if (targetGroups.length === 1 && options.stickinessDuration === undefined) {
+            // Render a "simple" action for backwards compatibility with old templates
+            return new TargetGroupListenerAction(targetGroups, {
+                type: "forward",
+                targetGroupArn: targetGroups[0].targetGroupArn,
+            });
+        }
+        return ListenerAction.weightedForward(targetGroups.map((g) => ({ targetGroup: g, weight: 1 })), options);
+    }
+    /**
+     * Forward to one or more Target Groups which are weighted differently
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#forward-actions
+     */
+    static weightedForward(targetGroups, options = {}) {
+        if (targetGroups.length === 0) {
+            throw new Error("Need at least one targetGroup in a ListenerAction.weightedForward()");
+        }
+        return new TargetGroupListenerAction(targetGroups.map((g) => g.targetGroup), {
+            type: "forward",
+            forward: {
+                targetGroup: targetGroups.map((g) => ({
+                    arn: g.targetGroup.targetGroupArn,
+                    weight: g.weight,
+                })),
+                stickiness: options.stickinessDuration
+                    ? {
+                        duration: options.stickinessDuration.toSeconds(),
+                        enabled: true,
+                    }
+                    : undefined,
+            },
+        });
+    }
+    /**
+     * Return a fixed response
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#fixed-response-actions
+     */
+    static fixedResponse(statusCode, options = {}) {
+        return new ListenerAction({
+            type: "fixed-response",
+            fixedResponse: {
+                statusCode: cdktf_1.Tokenization.stringifyNumber(statusCode),
+                contentType: options.contentType ?? "text/plain",
+                messageBody: options.messageBody,
+            },
+        });
+    }
+    /**
+     * Redirect to a different URI
+     *
+     * A URI consists of the following components:
+     * protocol://hostname:port/path?query. You must modify at least one of the
+     * following components to avoid a redirect loop: protocol, hostname, port, or
+     * path. Any components that you do not modify retain their original values.
+     *
+     * You can reuse URI components using the following reserved keywords:
+     *
+     * - `#{protocol}`
+     * - `#{host}`
+     * - `#{port}`
+     * - `#{path}` (the leading "/" is removed)
+     * - `#{query}`
+     *
+     * For example, you can change the path to "/new/#{path}", the hostname to
+     * "example.#{host}", or the query to "#{query}&value=xyz".
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#redirect-actions
+     */
+    static redirect(options) {
+        if ([
+            options.host,
+            options.path,
+            options.port,
+            options.protocol,
+            options.query,
+        ].findIndex((x) => x !== undefined) === -1) {
+            throw new Error("To prevent redirect loops, set at least one of 'protocol', 'host', 'port', 'path', or 'query'.");
+        }
+        if (options.path &&
+            !cdktf_1.Token.isUnresolved(options.path) &&
+            !options.path.startsWith("/")) {
+            throw new Error(`Redirect path must start with a \'/\', got: ${options.path}`);
+        }
+        return new ListenerAction({
+            type: "redirect",
+            redirect: {
+                statusCode: options.permanent ? "HTTP_301" : "HTTP_302",
+                host: options.host,
+                path: options.path,
+                port: options.port,
+                protocol: options.protocol,
+                query: options.query,
+            },
+        });
+    }
+    /**
+     * Create an instance of ListenerAction
+     *
+     * The default class should be good enough for most cases and
+     * should be created by using one of the static factory functions,
+     * but allow overriding to make sure we allow flexibility for the future.
+     */
+    constructor(defaultActionJson, next) {
+        this.defaultActionJson = defaultActionJson;
+        this.next = next;
+    }
+    /**
+     * Render the listener rule actions in this chain
+     */
+    renderRuleActions() {
+        const actionJson = this._actionJson ??
+            this.defaultActionJson;
+        return this._renumber([
+            actionJson,
+            ...(this.next?.renderRuleActions() ?? []),
+        ]);
+    }
+    /**
+     * Render the listener default actions in this chain
+     */
+    renderActions() {
+        return this._renumber([
+            this.defaultActionJson,
+            ...(this.next?.renderActions() ?? []),
+        ]);
+    }
+    /**
+     * Called when the action is being used in a listener
+     */
+    bind(scope, listener, associatingConstruct) {
+        this.next?.bind(scope, listener, associatingConstruct);
+    }
+    _renumber(actions) {
+        if (actions.length < 2) {
+            return actions;
+        }
+        return actions.map((action, i) => ({ ...action, order: i + 1 }));
+    }
+    /**
+     * Renumber the "order" fields in the actions array.
+     *
+     * We don't number for 0 or 1 elements, but otherwise number them 1...#actions
+     * so ELB knows about the right order.
+     *
+     * Do this in `ListenerAction` instead of in `Listener` so that we give
+     * users the opportunity to override by subclassing and overriding `renderActions`.
+     */
+    renumber(actions) {
+        return this._renumber(actions);
+    }
+    /**
+     * Sets the Action for the `ListenerRule`.
+     * This method is required to set a dedicated Action to a `ListenerRule`
+     * when the Action for the `CfnListener` and the Action for the `CfnListenerRule`
+     * have different structures. (e.g. `AuthenticateOidcConfig`)
+     * @param actionJson Action for `ListenerRule`
+     */
+    addRuleAction(actionJson) {
+        if (this._actionJson) {
+            throw new Error("rule action is already set");
+        }
+        this._actionJson = actionJson;
+    }
+}
+exports.ListenerAction = ListenerAction;
+_a = JSII_RTTI_SYMBOL_1;
+ListenerAction[_a] = { fqn: "terraconstructs.aws.compute.ListenerAction", version: "0.0.12" };
+/**
+ * What to do with unauthenticated requests
+ */
+var UnauthenticatedAction;
+(function (UnauthenticatedAction) {
+    /**
+     * Return an HTTP 401 Unauthorized error.
+     */
+    UnauthenticatedAction["DENY"] = "deny";
+    /**
+     * Allow the request to be forwarded to the target.
+     */
+    UnauthenticatedAction["ALLOW"] = "allow";
+    /**
+     * Redirect the request to the IdP authorization endpoint.
+     */
+    UnauthenticatedAction["AUTHENTICATE"] = "authenticate";
+})(UnauthenticatedAction || (exports.UnauthenticatedAction = UnauthenticatedAction = {}));
+/**
+ * Listener Action that calls "registerListener" on TargetGroups
+ */
+class TargetGroupListenerAction extends ListenerAction {
+    constructor(targetGroups, defaultActionJson) {
+        super(defaultActionJson);
+        this.targetGroups = targetGroups;
+    }
+    bind(_scope, listener, associatingConstruct) {
+        for (const tg of this.targetGroups) {
+            tg.registerListener(listener, associatingConstruct);
+        }
+    }
+}
+/**
+ * A Listener Action to authenticate with OIDC
+ */
+class AuthenticateOidcAction extends ListenerAction {
+    constructor(options) {
+        const defaultActionConfig = {
+            authorizationEndpoint: options.authorizationEndpoint,
+            clientId: options.clientId,
+            clientSecret: options.clientSecret, //.unsafeUnwrap(), // Safe usage
+            issuer: options.issuer,
+            tokenEndpoint: options.tokenEndpoint,
+            userInfoEndpoint: options.userInfoEndpoint,
+            authenticationRequestExtraParams: options.authenticationRequestExtraParams,
+            onUnauthenticatedRequest: options.onUnauthenticatedRequest,
+            scope: options.scope,
+            sessionCookieName: options.sessionCookieName,
+            sessionTimeout: options.sessionTimeout?.toSeconds(),
+        };
+        super({
+            type: "authenticate-oidc",
+            authenticateOidc: defaultActionConfig,
+        }, options.next);
+        this.allowHttpsOutbound = options.allowHttpsOutbound ?? true;
+        this.addRuleAction({
+            type: "authenticate-oidc",
+            authenticateOidc: {
+                ...defaultActionConfig,
+                sessionTimeout: options.sessionTimeout?.toSeconds(),
+            },
+        });
+    }
+    bind(scope, listener, associatingConstruct) {
+        super.bind(scope, listener, associatingConstruct);
+        if (!this.allowHttpsOutbound)
+            return;
+        listener.connections.allowToAnyIpv4(port_1.Port.tcp(443), "Allow to IdP endpoint");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application-listener-action.js","sourceRoot":"","sources":["../../../../src/aws/compute/alb/application-listener-action.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-elasticloadbalancingv2/lib/alb/application-listener-action.ts\n\nimport {\n  lbListener as tfListener,\n  lbListenerRule as tfListenerRule,\n} from \"@cdktf/provider-aws\";\nimport {\n  //SecretValue,\n  Token,\n  Tokenization,\n} from \"cdktf\";\nimport { Construct, IConstruct } from \"constructs\";\nimport { IApplicationListener } from \"./application-listener\";\nimport { IApplicationTargetGroup } from \"./application-target-group\";\nimport { Duration } from \"../../../duration\";\nimport { IListenerAction } from \"../lb-shared/listener-action\";\nimport { Port } from \"../port\";\n\n/**\n * What to do when a client makes a request to a listener\n *\n * Some actions can be combined with other ones (specifically,\n * you can perform authentication before serving the request).\n *\n * Multiple actions form a linked chain; the chain must always terminate in a\n * *(weighted)forward*, *fixedResponse* or *redirect* action.\n *\n * If an action supports chaining, the next action can be indicated\n * by passing it in the `next` property.\n *\n * (Called `ListenerAction` instead of the more strictly correct\n * `ListenerAction` because this is the class most users interact\n * with, and we want to make it not too visually overwhelming).\n */\nexport class ListenerAction implements IListenerAction {\n  /**\n   * Authenticate using an identity provider (IdP) that is compliant with OpenID Connect (OIDC)\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/listener-authenticate-users.html#oidc-requirements\n   */\n  public static authenticateOidc(\n    options: AuthenticateOidcOptions,\n  ): ListenerAction {\n    return new AuthenticateOidcAction(options);\n  }\n\n  /**\n   * Forward to one or more Target Groups\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#forward-actions\n   */\n  public static forward(\n    targetGroups: IApplicationTargetGroup[],\n    options: ForwardOptions = {},\n  ): ListenerAction {\n    if (targetGroups.length === 0) {\n      throw new Error(\n        \"Need at least one targetGroup in a ListenerAction.forward()\",\n      );\n    }\n    if (targetGroups.length === 1 && options.stickinessDuration === undefined) {\n      // Render a \"simple\" action for backwards compatibility with old templates\n      return new TargetGroupListenerAction(targetGroups, {\n        type: \"forward\",\n        targetGroupArn: targetGroups[0].targetGroupArn,\n      });\n    }\n\n    return ListenerAction.weightedForward(\n      targetGroups.map((g) => ({ targetGroup: g, weight: 1 })),\n      options,\n    );\n  }\n\n  /**\n   * Forward to one or more Target Groups which are weighted differently\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#forward-actions\n   */\n  public static weightedForward(\n    targetGroups: WeightedTargetGroup[],\n    options: ForwardOptions = {},\n  ): ListenerAction {\n    if (targetGroups.length === 0) {\n      throw new Error(\n        \"Need at least one targetGroup in a ListenerAction.weightedForward()\",\n      );\n    }\n\n    return new TargetGroupListenerAction(\n      targetGroups.map((g) => g.targetGroup),\n      {\n        type: \"forward\",\n        forward: {\n          targetGroup: targetGroups.map((g) => ({\n            arn: g.targetGroup.targetGroupArn,\n            weight: g.weight,\n          })),\n          stickiness: options.stickinessDuration\n            ? {\n                duration: options.stickinessDuration.toSeconds(),\n                enabled: true,\n              }\n            : undefined,\n        },\n      },\n    );\n  }\n\n  /**\n   * Return a fixed response\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#fixed-response-actions\n   */\n  public static fixedResponse(\n    statusCode: number,\n    options: FixedResponseOptions = {},\n  ): ListenerAction {\n    return new ListenerAction({\n      type: \"fixed-response\",\n      fixedResponse: {\n        statusCode: Tokenization.stringifyNumber(statusCode),\n        contentType: options.contentType ?? \"text/plain\",\n        messageBody: options.messageBody,\n      },\n    });\n  }\n\n  /**\n   * Redirect to a different URI\n   *\n   * A URI consists of the following components:\n   * protocol://hostname:port/path?query. You must modify at least one of the\n   * following components to avoid a redirect loop: protocol, hostname, port, or\n   * path. Any components that you do not modify retain their original values.\n   *\n   * You can reuse URI components using the following reserved keywords:\n   *\n   * - `#{protocol}`\n   * - `#{host}`\n   * - `#{port}`\n   * - `#{path}` (the leading \"/\" is removed)\n   * - `#{query}`\n   *\n   * For example, you can change the path to \"/new/#{path}\", the hostname to\n   * \"example.#{host}\", or the query to \"#{query}&value=xyz\".\n   *\n   * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#redirect-actions\n   */\n  public static redirect(options: RedirectOptions): ListenerAction {\n    if (\n      [\n        options.host,\n        options.path,\n        options.port,\n        options.protocol,\n        options.query,\n      ].findIndex((x) => x !== undefined) === -1\n    ) {\n      throw new Error(\n        \"To prevent redirect loops, set at least one of 'protocol', 'host', 'port', 'path', or 'query'.\",\n      );\n    }\n    if (\n      options.path &&\n      !Token.isUnresolved(options.path) &&\n      !options.path.startsWith(\"/\")\n    ) {\n      throw new Error(\n        `Redirect path must start with a \\'/\\', got: ${options.path}`,\n      );\n    }\n\n    return new ListenerAction({\n      type: \"redirect\",\n      redirect: {\n        statusCode: options.permanent ? \"HTTP_301\" : \"HTTP_302\",\n        host: options.host,\n        path: options.path,\n        port: options.port,\n        protocol: options.protocol,\n        query: options.query,\n      },\n    });\n  }\n\n  /**\n   * If set, it is preferred as Action for the `ListenerRule`.\n   * This is necessary if `CfnListener.ActionProperty` and `CfnListenerRule.ActionProperty`\n   * have different structures.\n   */\n  private _actionJson?: tfListenerRule.LbListenerRuleAction;\n\n  /**\n   * Create an instance of ListenerAction\n   *\n   * The default class should be good enough for most cases and\n   * should be created by using one of the static factory functions,\n   * but allow overriding to make sure we allow flexibility for the future.\n   */\n  protected constructor(\n    private readonly defaultActionJson: tfListener.LbListenerDefaultAction,\n    protected readonly next?: ListenerAction,\n  ) {}\n\n  /**\n   * Render the listener rule actions in this chain\n   */\n  public renderRuleActions(): tfListenerRule.LbListenerRuleAction[] {\n    const actionJson =\n      this._actionJson ??\n      (this.defaultActionJson as tfListenerRule.LbListenerRuleAction);\n    return this._renumber([\n      actionJson,\n      ...(this.next?.renderRuleActions() ?? []),\n    ]);\n  }\n\n  /**\n   * Render the listener default actions in this chain\n   */\n  public renderActions(): tfListener.LbListenerDefaultAction[] {\n    return this._renumber([\n      this.defaultActionJson,\n      ...(this.next?.renderActions() ?? []),\n    ]);\n  }\n\n  /**\n   * Called when the action is being used in a listener\n   */\n  public bind(\n    scope: Construct,\n    listener: IApplicationListener,\n    associatingConstruct?: IConstruct,\n  ) {\n    this.next?.bind(scope, listener, associatingConstruct);\n  }\n\n  private _renumber<\n    ActionProperty extends\n      | tfListener.LbListenerDefaultAction\n      | tfListenerRule.LbListenerRuleAction = tfListener.LbListenerDefaultAction,\n  >(actions: ActionProperty[]): ActionProperty[] {\n    if (actions.length < 2) {\n      return actions;\n    }\n\n    return actions.map((action, i) => ({ ...action, order: i + 1 }));\n  }\n\n  /**\n   * Renumber the \"order\" fields in the actions array.\n   *\n   * We don't number for 0 or 1 elements, but otherwise number them 1...#actions\n   * so ELB knows about the right order.\n   *\n   * Do this in `ListenerAction` instead of in `Listener` so that we give\n   * users the opportunity to override by subclassing and overriding `renderActions`.\n   */\n  protected renumber(\n    actions: tfListener.LbListenerDefaultAction[],\n  ): tfListener.LbListenerDefaultAction[] {\n    return this._renumber(actions);\n  }\n\n  /**\n   * Sets the Action for the `ListenerRule`.\n   * This method is required to set a dedicated Action to a `ListenerRule`\n   * when the Action for the `CfnListener` and the Action for the `CfnListenerRule`\n   * have different structures. (e.g. `AuthenticateOidcConfig`)\n   * @param actionJson Action for `ListenerRule`\n   */\n  protected addRuleAction(actionJson: tfListenerRule.LbListenerRuleAction) {\n    if (this._actionJson) {\n      throw new Error(\"rule action is already set\");\n    }\n    this._actionJson = actionJson;\n  }\n}\n\n/**\n * Options for `ListenerAction.forward()`\n */\nexport interface ForwardOptions {\n  /**\n   * For how long clients should be directed to the same target group\n   *\n   * Range between 1 second and 7 days.\n   *\n   * @default - No stickiness\n   */\n  readonly stickinessDuration?: Duration;\n}\n\n/**\n * A Target Group and weight combination\n */\nexport interface WeightedTargetGroup {\n  /**\n   * The target group\n   */\n  readonly targetGroup: IApplicationTargetGroup;\n\n  /**\n   * The target group's weight\n   *\n   * Range is [0..1000).\n   *\n   * @default 1\n   */\n  readonly weight?: number;\n}\n\n/**\n * Options for `ListenerAction.fixedResponse()`\n */\nexport interface FixedResponseOptions {\n  /**\n   * Content Type of the response\n   *\n   * Valid Values: text/plain | text/css | text/html | application/javascript | application/json\n   */\n  readonly contentType?: string;\n\n  // TODO: Automatically determine content type?\n  // * @default - Automatically determined\n  // Required in elbv2 - CreateRule - API Call\n  // https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_FixedResponseActionConfig.html\n  // Optional in CloudFormation resource\n  // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticloadbalancingv2-listener-fixedresponseconfig.html#cfn-elasticloadbalancingv2-listener-fixedresponseconfig-contenttype\n\n  /**\n   * The response body\n   *\n   * @default - No body\n   */\n  readonly messageBody?: string;\n}\n\n/**\n * Options for `ListenerAction.redirect()`\n *\n * A URI consists of the following components:\n * protocol://hostname:port/path?query. You must modify at least one of the\n * following components to avoid a redirect loop: protocol, hostname, port, or\n * path. Any components that you do not modify retain their original values.\n *\n * You can reuse URI components using the following reserved keywords:\n *\n * - `#{protocol}`\n * - `#{host}`\n * - `#{port}`\n * - `#{path}` (the leading \"/\" is removed)\n * - `#{query}`\n *\n * For example, you can change the path to \"/new/#{path}\", the hostname to\n * \"example.#{host}\", or the query to \"#{query}&value=xyz\".\n */\nexport interface RedirectOptions {\n  /**\n   * The hostname.\n   *\n   * This component is not percent-encoded. The hostname can contain #{host}.\n   *\n   * @default - No change\n   */\n  readonly host?: string;\n\n  /**\n   * The absolute path, starting with the leading \"/\".\n   *\n   * This component is not percent-encoded. The path can contain #{host}, #{path}, and #{port}.\n   *\n   * @default - No change\n   */\n  readonly path?: string;\n\n  /**\n   * The port.\n   *\n   * You can specify a value from 1 to 65535 or #{port}.\n   *\n   * @default - No change\n   */\n  readonly port?: string;\n\n  /**\n   * The protocol.\n   *\n   * You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP to HTTP, HTTP to HTTPS, and HTTPS to HTTPS. You cannot redirect HTTPS to HTTP.\n   *\n   * @default - No change\n   */\n  readonly protocol?: string;\n\n  /**\n   * The query parameters, URL-encoded when necessary, but not percent-encoded.\n   *\n   * Do not include the leading \"?\", as it is automatically added. You can specify any of the reserved keywords.\n   *\n   * @default - No change\n   */\n  readonly query?: string;\n\n  /**\n   * The HTTP redirect code.\n   *\n   * The redirect is either permanent (HTTP 301) or temporary (HTTP 302).\n   *\n   * @default false\n   */\n  readonly permanent?: boolean;\n}\n\n/**\n * Options for `ListenerAction.authenciateOidc()`\n */\nexport interface AuthenticateOidcOptions {\n  /**\n   * What action to execute next\n   */\n  readonly next: ListenerAction;\n\n  /**\n   * The query parameters (up to 10) to include in the redirect request to the authorization endpoint.\n   *\n   * @default - No extra parameters\n   */\n  readonly authenticationRequestExtraParams?: Record<string, string>;\n\n  /**\n   * The authorization endpoint of the IdP.\n   *\n   * This must be a full URL, including the HTTPS protocol, the domain, and the path.\n   */\n  readonly authorizationEndpoint: string;\n\n  /**\n   * The OAuth 2.0 client identifier.\n   */\n  readonly clientId: string;\n\n  /**\n   * The OAuth 2.0 client secret.\n   */\n  readonly clientSecret: string; //SecretValue;\n\n  /**\n   * The OIDC issuer identifier of the IdP.\n   *\n   * This must be a full URL, including the HTTPS protocol, the domain, and the path.\n   */\n  readonly issuer: string;\n\n  /**\n   * The behavior if the user is not authenticated.\n   *\n   * @default UnauthenticatedAction.AUTHENTICATE\n   */\n  readonly onUnauthenticatedRequest?: UnauthenticatedAction;\n\n  /**\n   * The set of user claims to be requested from the IdP.\n   *\n   * To verify which scope values your IdP supports and how to separate multiple values, see the documentation for your IdP.\n   *\n   * @default \"openid\"\n   */\n  readonly scope?: string;\n\n  /**\n   * The name of the cookie used to maintain session information.\n   *\n   * @default \"AWSELBAuthSessionCookie\"\n   */\n  readonly sessionCookieName?: string;\n\n  /**\n   * The maximum duration of the authentication session.\n   *\n   * @default Duration.days(7)\n   */\n  readonly sessionTimeout?: Duration;\n\n  /**\n   * The token endpoint of the IdP.\n   *\n   * This must be a full URL, including the HTTPS protocol, the domain, and the path.\n   */\n  readonly tokenEndpoint: string;\n\n  /**\n   * The user info endpoint of the IdP.\n   *\n   * This must be a full URL, including the HTTPS protocol, the domain, and the path.\n   */\n  readonly userInfoEndpoint: string;\n\n  /**\n   * Allow HTTPS outbound traffic to communicate with the IdP.\n   *\n   * Set this property to false if the IP address used for the IdP endpoint is identifiable\n   * and you want to control outbound traffic.\n   * Then allow HTTPS outbound traffic to the IdP's IP address using the listener's `connections` property.\n   *\n   * @default true\n   * @see https://repost.aws/knowledge-center/elb-configure-authentication-alb\n   */\n  readonly allowHttpsOutbound?: boolean;\n}\n\n/**\n * What to do with unauthenticated requests\n */\nexport enum UnauthenticatedAction {\n  /**\n   * Return an HTTP 401 Unauthorized error.\n   */\n  DENY = \"deny\",\n\n  /**\n   * Allow the request to be forwarded to the target.\n   */\n  ALLOW = \"allow\",\n\n  /**\n   * Redirect the request to the IdP authorization endpoint.\n   */\n  AUTHENTICATE = \"authenticate\",\n}\n\n/**\n * Listener Action that calls \"registerListener\" on TargetGroups\n */\nclass TargetGroupListenerAction extends ListenerAction {\n  constructor(\n    private readonly targetGroups: IApplicationTargetGroup[],\n    defaultActionJson: tfListener.LbListenerDefaultAction,\n  ) {\n    super(defaultActionJson);\n  }\n\n  public bind(\n    _scope: Construct,\n    listener: IApplicationListener,\n    associatingConstruct?: IConstruct,\n  ) {\n    for (const tg of this.targetGroups) {\n      tg.registerListener(listener, associatingConstruct);\n    }\n  }\n}\n\n/**\n * A Listener Action to authenticate with OIDC\n */\nclass AuthenticateOidcAction extends ListenerAction {\n  private readonly allowHttpsOutbound: boolean;\n\n  constructor(options: AuthenticateOidcOptions) {\n    const defaultActionConfig: tfListener.LbListenerDefaultActionAuthenticateOidc =\n      {\n        authorizationEndpoint: options.authorizationEndpoint,\n        clientId: options.clientId,\n        clientSecret: options.clientSecret, //.unsafeUnwrap(), // Safe usage\n        issuer: options.issuer,\n        tokenEndpoint: options.tokenEndpoint,\n        userInfoEndpoint: options.userInfoEndpoint,\n        authenticationRequestExtraParams:\n          options.authenticationRequestExtraParams,\n        onUnauthenticatedRequest: options.onUnauthenticatedRequest,\n        scope: options.scope,\n        sessionCookieName: options.sessionCookieName,\n        sessionTimeout: options.sessionTimeout?.toSeconds(),\n      };\n    super(\n      {\n        type: \"authenticate-oidc\",\n        authenticateOidc: defaultActionConfig,\n      },\n      options.next,\n    );\n\n    this.allowHttpsOutbound = options.allowHttpsOutbound ?? true;\n    this.addRuleAction({\n      type: \"authenticate-oidc\",\n      authenticateOidc: {\n        ...defaultActionConfig,\n        sessionTimeout: options.sessionTimeout?.toSeconds(),\n      },\n    });\n  }\n  public bind(\n    scope: Construct,\n    listener: IApplicationListener,\n    associatingConstruct?: IConstruct | undefined,\n  ): void {\n    super.bind(scope, listener, associatingConstruct);\n\n    if (!this.allowHttpsOutbound) return;\n    listener.connections.allowToAnyIpv4(Port.tcp(443), \"Allow to IdP endpoint\");\n  }\n}\n"]}

package/lib/aws/compute/alb/application-listener-certificate.d.ts

@@ -0,0 +1,35 @@
+import { Construct } from "constructs";
+import { IApplicationListener } from "./application-listener";
+import { IListenerCertificate } from "../lb-shared/listener-certificate";
+/**
+ * Properties for adding a set of certificates to a listener
+ */
+export interface ApplicationListenerCertificateProps {
+    /**
+     * The listener to attach the rule to
+     */
+    readonly listener: IApplicationListener;
+    /**
+     * ARNs of certificates to attach
+     *
+     * Duplicates are not allowed.
+     *
+     * @deprecated Use `certificates` instead.
+     * @default - One of 'certificates' and 'certificateArns' is required.
+     */
+    readonly certificateArns?: string[];
+    /**
+     * Certificates to attach
+     *
+     * Duplicates are not allowed.
+     *
+     * @default - One of 'certificates' and 'certificateArns' is required.
+     */
+    readonly certificates?: IListenerCertificate[];
+}
+/**
+ * Add certificates to a listener
+ */
+export declare class ApplicationListenerCertificate extends Construct {
+    constructor(scope: Construct, id: string, props: ApplicationListenerCertificateProps);
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationListenerCertificate = 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-certificate.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const constructs_1 = require("constructs");
+/**
+ * Add certificates to a listener
+ */
+class ApplicationListenerCertificate extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        if (!props.certificateArns && !props.certificates) {
+            throw new Error("At least one of 'certificateArns' or 'certificates' is required");
+        }
+        const certificates = [
+            ...(props.certificates || []).map((c) => ({
+                certificateArn: c.certificateArn,
+            })),
+            ...(props.certificateArns || []).map((certificateArn) => ({
+                certificateArn,
+            })),
+        ];
+        new provider_aws_1.lbListenerCertificate.LbListenerCertificate(this, "Resource", {
+            listenerArn: props.listener.listenerArn,
+            certificateArn: certificates[0].certificateArn,
+        });
+    }
+}
+exports.ApplicationListenerCertificate = ApplicationListenerCertificate;
+_a = JSII_RTTI_SYMBOL_1;
+ApplicationListenerCertificate[_a] = { fqn: "terraconstructs.aws.compute.ApplicationListenerCertificate", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/alb/application-listener-rule.d.ts

@@ -0,0 +1,233 @@
+import { Construct } from "constructs";
+import { IApplicationListener } from "./application-listener";
+import { ListenerAction } from "./application-listener-action";
+import { IApplicationTargetGroup } from "./application-target-group";
+import { ListenerCondition } from "./conditions";
+/**
+ * Basic properties for defining a rule on a listener
+ */
+export interface BaseApplicationListenerRuleProps {
+    /**
+     * Priority of the rule
+     *
+     * The rule with the lowest priority will be used for every request.
+     *
+     * Priorities must be unique.
+     */
+    readonly priority: number;
+    /**
+     * Target groups to forward requests to.
+     *
+     * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.
+     *
+     * Implies a `forward` action.
+     *
+     * @default - No target groups.
+     */
+    readonly targetGroups?: IApplicationTargetGroup[];
+    /**
+     * Action to perform when requests are received
+     *
+     * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.
+     *
+     * @default - No action
+     */
+    readonly action?: ListenerAction;
+    /**
+     * Fixed response to return.
+     *
+     * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.
+     *
+     * @default - No fixed response.
+     * @deprecated Use `action` instead.
+     */
+    readonly fixedResponse?: FixedResponse;
+    /**
+     * Redirect response to return.
+     *
+     * Only one of `action`, `fixedResponse`, `redirectResponse` or `targetGroups` can be specified.
+     *
+     * @default - No redirect response.
+     * @deprecated Use `action` instead.
+     */
+    readonly redirectResponse?: RedirectResponse;
+    /**
+     * Rule applies if matches the conditions.
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html
+     *
+     * @default - No conditions.
+     */
+    readonly conditions?: ListenerCondition[];
+    /**
+     * Rule applies if the requested host matches the indicated host
+     *
+     * May contain up to three '*' wildcards.
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#host-conditions
+     *
+     * @default - No host condition.
+     * @deprecated Use `conditions` instead.
+     */
+    readonly hostHeader?: string;
+    /**
+     * Rule applies if the requested path matches the given path pattern
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions
+     * @default - No path condition.
+     * @deprecated Use `conditions` instead.
+     */
+    readonly pathPattern?: string;
+    /**
+     * Rule applies if the requested path matches any of the given patterns.
+     *
+     * Paths may contain up to three '*' wildcards.
+     *
+     * @see https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#path-conditions
+     * @default - No path conditions.
+     * @deprecated Use `conditions` instead.
+     */
+    readonly pathPatterns?: string[];
+}
+/**
+ * Properties for defining a listener rule
+ */
+export interface ApplicationListenerRuleProps extends BaseApplicationListenerRuleProps {
+    /**
+     * The listener to attach the rule to
+     */
+    readonly listener: IApplicationListener;
+}
+/**
+ * The content type for a fixed response
+ * @deprecated superseded by `FixedResponseOptions`.
+ */
+export declare enum ContentType {
+    TEXT_PLAIN = "text/plain",
+    TEXT_CSS = "text/css",
+    TEXT_HTML = "text/html",
+    APPLICATION_JAVASCRIPT = "application/javascript",
+    APPLICATION_JSON = "application/json"
+}
+/**
+ * A fixed response
+ * @deprecated superseded by `ListenerAction.fixedResponse()`.
+ */
+export interface FixedResponse {
+    /**
+     * The HTTP response code (2XX, 4XX or 5XX)
+     */
+    readonly statusCode: string;
+    /**
+     * The content type
+     *
+     * @default text/plain
+     */
+    readonly contentType?: ContentType;
+    /**
+     * The message
+     *
+     * @default no message
+     */
+    readonly messageBody?: string;
+}
+/**
+ * A redirect response
+ * @deprecated superseded by `ListenerAction.redirect()`.
+ */
+export interface RedirectResponse {
+    /**
+     * The hostname. This component is not percent-encoded. The hostname can contain #{host}.
+     *
+     * @default origin host of request
+     */
+    readonly host?: string;
+    /**
+     * The absolute path, starting with the leading "/". This component is not percent-encoded.
+     * The path can contain #{host}, #{path}, and #{port}.
+     *
+     * @default origin path of request
+     */
+    readonly path?: string;
+    /**
+     * The port. You can specify a value from 1 to 65535 or #{port}.
+     *
+     * @default origin port of request
+     */
+    readonly port?: string;
+    /**
+     * The protocol. You can specify HTTP, HTTPS, or #{protocol}. You can redirect HTTP to HTTP,
+     * HTTP to HTTPS, and HTTPS to HTTPS. You cannot redirect HTTPS to HTTP.
+     *
+     * @default origin protocol of request
+     */
+    readonly protocol?: string;
+    /**
+     * The query parameters, URL-encoded when necessary, but not percent-encoded.
+     * Do not include the leading "?", as it is automatically added.
+     * You can specify any of the reserved keywords.
+     *
+     * @default origin query string of request
+     */
+    readonly query?: string;
+    /**
+     * The HTTP redirect code (HTTP_301 or HTTP_302)
+     */
+    readonly statusCode: string;
+}
+/**
+ * Define a new listener rule
+ */
+export declare class ApplicationListenerRule extends Construct {
+    /**
+     * The ARN of this rule
+     */
+    readonly listenerRuleArn: string;
+    private readonly conditions;
+    private readonly legacyConditions;
+    private readonly listener;
+    private action?;
+    constructor(scope: Construct, id: string, props: ApplicationListenerRuleProps);
+    /**
+     * 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: string, values: string[] | undefined): void;
+    /**
+     * Add a non-standard condition to this rule
+     */
+    addCondition(condition: ListenerCondition): void;
+    /**
+     * Configure the action to perform for this rule
+     */
+    configureAction(action: ListenerAction): void;
+    /**
+     * Add a TargetGroup to load balance to
+     *
+     * @deprecated Use configureAction instead
+     */
+    addTargetGroup(targetGroup: IApplicationTargetGroup): void;
+    /**
+     * Add a fixed response
+     *
+     * @deprecated Use configureAction instead
+     */
+    addFixedResponse(fixedResponse: FixedResponse): void;
+    /**
+     * Add a redirect response
+     *
+     * @deprecated Use configureAction instead
+     */
+    addRedirectResponse(redirectResponse: RedirectResponse): void;
+    /**
+     * Validate the rule
+     */
+    private validateListenerRule;
+    /**
+     * Render the conditions for this rule
+     */
+    private renderConditions;
+}