terraconstructs 0.0.8

package/lib/aws/notify/event-bus.js

@@ -0,0 +1,326 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBridgePermission = exports.EventBusPolicy = exports.EventBus = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const archive_1 = require("./archive");
+// import * as encryption from "../encryption";
+const iam = require("../iam");
+class EventBusBase extends aws_construct_1.AwsConstructBase {
+    archive(id, props) {
+        return new archive_1.Archive(this, id, {
+            sourceEventBus: this,
+            description: props.description || `Event Archive for ${this.eventBusName} Event Bus`,
+            eventPattern: props.eventPattern,
+            retention: props.retention,
+            archiveName: props.archiveName,
+        });
+    }
+    grantPutEventsTo(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["events:PutEvents"],
+            resourceArns: [this.eventBusArn],
+        });
+    }
+}
+/**
+ * Define an EventBridge EventBus
+ *
+ * @resource aws_cloudwatch_event_bus
+ */
+class EventBus extends EventBusBase {
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param eventBusArn ARN of imported event bus
+     */
+    static fromEventBusArn(scope, id, eventBusArn) {
+        const parts = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(eventBusArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        return new ImportedEventBus(scope, id, {
+            eventBusArn: eventBusArn,
+            eventBusName: parts.resourceName || "",
+        });
+    }
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param eventBusName Name of imported event bus
+     */
+    static fromEventBusName(scope, id, eventBusName) {
+        const eventBusArn = aws_stack_1.AwsStack.ofAwsConstruct(scope).formatArn({
+            resource: "event-bus",
+            service: "events",
+            resourceName: eventBusName,
+        });
+        return EventBus.fromEventBusAttributes(scope, id, {
+            eventBusName: eventBusName,
+            eventBusArn: eventBusArn,
+        });
+    }
+    /**
+     * Import an existing event bus resource
+     * @param scope Parent construct
+     * @param id Construct ID
+     * @param attrs Imported event bus properties
+     */
+    static fromEventBusAttributes(scope, id, attrs) {
+        return new ImportedEventBus(scope, id, attrs);
+    }
+    /**
+     * Permits an IAM Principal to send custom events to EventBridge
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     * @deprecated use grantAllPutEvents instead
+     */
+    static grantPutEvents(grantee) {
+        // It's currently not possible to restrict PutEvents to specific resources.
+        // See https://docs.aws.amazon.com/eventbridge/latest/userguide/permissions-reference-eventbridge.html
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["events:PutEvents"],
+            resourceArns: ["*"],
+        });
+    }
+    /**
+     * Permits an IAM Principal to send custom events to EventBridge
+     * so that they can be matched to rules.
+     *
+     * @param grantee The principal (no-op if undefined)
+     */
+    static grantAllPutEvents(grantee) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions: ["events:PutEvents"],
+            resourceArns: ["*"],
+        });
+    }
+    static eventBusProps(defaultEventBusName, props = {}) {
+        const { eventBusName, eventSourceName } = props;
+        const eventBusNameRegex = /^[\/\.\-_A-Za-z0-9]{1,256}$/;
+        if (eventBusName !== undefined && eventSourceName !== undefined) {
+            throw new Error("'eventBusName' and 'eventSourceName' cannot both be provided");
+        }
+        if (eventBusName !== undefined) {
+            if (!cdktf_1.Token.isUnresolved(eventBusName)) {
+                if (eventBusName === "default") {
+                    throw new Error("'eventBusName' must not be 'default'");
+                }
+                else if (eventBusName.indexOf("/") > -1) {
+                    throw new Error("'eventBusName' must not contain '/'");
+                }
+                else if (!eventBusNameRegex.test(eventBusName)) {
+                    throw new Error(`'eventBusName' must satisfy: ${eventBusNameRegex}`);
+                }
+            }
+            return { eventBusName };
+        }
+        if (eventSourceName !== undefined) {
+            if (!cdktf_1.Token.isUnresolved(eventSourceName)) {
+                // Ex: aws.partner/PartnerName/acct1/repo1
+                const eventSourceNameRegex = /^aws\.partner(\/[\.\-_A-Za-z0-9]+){2,}$/;
+                if (!eventSourceNameRegex.test(eventSourceName)) {
+                    throw new Error(`'eventSourceName' must satisfy: ${eventSourceNameRegex}`);
+                }
+                else if (!eventBusNameRegex.test(eventSourceName)) {
+                    throw new Error(`'eventSourceName' must satisfy: ${eventBusNameRegex}`);
+                }
+            }
+            return { eventBusName: eventSourceName, eventSourceName };
+        }
+        return { eventBusName: defaultEventBusName };
+    }
+    get outputs() {
+        return this.eventBusOutputs;
+    }
+    /**
+     * The physical ID of this event bus resource
+     */
+    get eventBusName() {
+        return this.resource.name;
+    }
+    /**
+     * The ARN of the event bus, such as:
+     * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.
+     */
+    get eventBusArn() {
+        return this.resource.arn;
+    }
+    constructor(scope, id, props) {
+        const { eventBusName, eventSourceName } = EventBus.eventBusProps(
+        // TODO(vincent): Figure out how this works...
+        cdktf_1.Lazy.stringValue({ produce: () => aws_stack_1.AwsStack.uniqueId(this) }), props);
+        super(scope, id, props);
+        // if (
+        //   props?.description &&
+        //   !Token.isUnresolved(props.description) &&
+        //   props.description.length > 512
+        // ) {
+        //   throw new Error(
+        //     `description must be less than or equal to 512 characters, got ${props.description.length}`,
+        //   );
+        // }
+        this.resource = new provider_aws_1.cloudwatchEventBus.CloudwatchEventBus(this, "Resource", {
+            name: eventBusName,
+            eventSourceName,
+            // kmsKeyIdentifier: props?.kmsKey?.keyArn, // TODO: Re-add KMS support
+            // description: props?.description, // Description is not supported by terraform-provider-aws
+        });
+        // TODO: Re-add KMS support
+        // /**
+        //  * Allow EventBridge to use customer managed key
+        //  *
+        //  * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-encryption-key-policy.html#eb-encryption-key-policy-bus
+        //  */
+        // if (props?.kmsKey) {
+        //   props?.kmsKey.addToResourcePolicy(
+        //     new iam.PolicyStatement({
+        //       resources: ["*"],
+        //       actions: ["kms:Decrypt", "kms:GenerateDataKey", "kms:DescribeKey"],
+        //       principals: [new iam.ServicePrincipal("events.amazonaws.com")],
+        //       conditions: {
+        //         StringEquals: {
+        //           "aws:SourceAccount": this.stack.account,
+        //           "aws:SourceArn": AwsStack.ofAwsConstruct(this).formatArn({
+        //             service: "events",
+        //             resource: "event-bus",
+        //             resourceName: eventBusName,
+        //           }),
+        //           "kms:EncryptionContext:aws:events:event-bus:arn": AwsStack.ofAwsConstruct(
+        //             this,
+        //           ).formatArn({
+        //             service: "events",
+        //             resource: "event-bus",
+        //             resourceName: eventBusName,
+        //           }),
+        //         },
+        //       },
+        //     }),
+        //   );
+        // }
+        this.eventSourceName = this.resource.eventSourceName;
+        this.eventBusOutputs = {
+            name: this.eventBusName,
+            arn: this.eventBusArn,
+            eventSourceName: this.eventSourceName,
+        };
+    }
+    /**
+     * Adds a statement to the IAM resource policy associated with this event bus.
+     */
+    addToResourcePolicy(statement) {
+        if (!this.policy) {
+            this.policy = new EventBusPolicy(this, "Policy", { eventBus: this });
+        }
+        if (this.policy) {
+            this.policy.document.addStatements(statement);
+            return { statementAdded: true, policyDependable: this.policy };
+        }
+        return { statementAdded: false };
+    }
+}
+exports.EventBus = EventBus;
+_a = JSII_RTTI_SYMBOL_1;
+EventBus[_a] = { fqn: "terraconstructs.aws.notify.EventBus", version: "0.0.8" };
+class ImportedEventBus extends EventBusBase {
+    get outputs() {
+        return this.eventBusOutputs;
+    }
+    constructor(scope, id, attrs) {
+        const arnParts = aws_stack_1.AwsStack.ofAwsConstruct(scope).splitArn(attrs.eventBusArn, arn_1.ArnFormat.SLASH_RESOURCE_NAME);
+        super(scope, id, {
+            account: arnParts.account,
+            region: arnParts.region,
+        });
+        this.eventBusArn = attrs.eventBusArn;
+        this.eventBusName = attrs.eventBusName;
+        this.eventSourceName = attrs.eventSourceName;
+        this.eventBusOutputs = {
+            name: this.eventBusName,
+            arn: this.eventBusArn,
+            eventSourceName: this.eventSourceName,
+        };
+    }
+    addToResourcePolicy(_statement) {
+        throw new Error([
+            "Cannot add a statement to an imported EventBus. You may use `EventBridgePermission` instead.",
+            "If the EventBus already has a policy attached, the permissions will be overwritten.",
+        ].join("\n"));
+    }
+}
+/**
+ * The policy for an Event Bus
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * The EventBusPolicy resource (`aws_cloudwatch_event_bus_policy`)
+ * is incompatible with the EventBridgePermission resource (`aws_cloudwatch_event_permission`)
+ * and will overwrite permissions.
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * Prefer to use `addToResourcePolicy()` instead.
+ *
+ * @resource aws_cloudwatch_event_bus_policy
+ */
+class EventBusPolicy extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return this.document.outputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.document = new iam.PolicyDocument(this, "Document");
+        new provider_aws_1.cloudwatchEventBusPolicy.CloudwatchEventBusPolicy(this, "Resource", {
+            // https://github.com/hashicorp/terraform-provider-aws/pull/16874#discussion_r656024830
+            policy: this.document.json,
+            eventBusName: props.eventBus.eventBusName,
+        });
+    }
+}
+exports.EventBusPolicy = EventBusPolicy;
+_b = JSII_RTTI_SYMBOL_1;
+EventBusPolicy[_b] = { fqn: "terraconstructs.aws.notify.EventBusPolicy", version: "0.0.8" };
+/**
+ * A single permission for an Event Bus
+ *
+ * All AWS resources that support resource policies have a method called
+ * `addToResourcePolicy()`, which will automatically create a new resource
+ * policy if one doesn't exist yet, otherwise it will add to the existing
+ * policy.
+ *
+ * If `addToResourcePolicy()` was used on the event bus, The EventBusPolicy resource
+ * (`aws_cloudwatch_event_bus_policy`) is incompatible with this resource and
+ * will overwrite permissions.
+ *
+ * @resource aws_cloudwatch_event_permission
+ */
+class EventBridgePermission extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {};
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        new provider_aws_1.cloudwatchEventPermission.CloudwatchEventPermission(this, "Resource", {
+            // https://github.com/hashicorp/terraform-provider-aws/pull/16874#discussion_r656024830
+            ...props,
+            eventBusName: props.eventBus.eventBusName,
+        });
+    }
+}
+exports.EventBridgePermission = EventBridgePermission;
+_c = JSII_RTTI_SYMBOL_1;
+EventBridgePermission[_c] = { fqn: "terraconstructs.aws.notify.EventBridgePermission", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-bus.js","sourceRoot":"","sources":["../../../src/aws/notify/event-bus.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  cloudwatchEventBus,\n  cloudwatchEventBusPolicy,\n  cloudwatchEventPermission,\n} from \"@cdktf/provider-aws\";\nimport { Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { Archive, BaseArchiveProps } from \"./archive\";\n// import * as encryption from \"../encryption\";\nimport * as iam from \"../iam\";\n\n/**\n * Outputs to register with the Grid\n */\nexport interface EventBusOutputs {\n  /**\n   * The physical ID of this event bus resource\n   */\n  readonly name: string;\n\n  /**\n   * The ARN of this event bus resource\n   */\n  readonly arn: string;\n\n  /**\n   * The partner event source to associate with this event bus resource\n   */\n  readonly eventSourceName?: string;\n}\n\n/**\n * Interface which all EventBus based classes MUST implement\n */\nexport interface IEventBus extends iam.IAwsConstructWithPolicy {\n  /**\n   * The physical ID of this event bus resource\n   *\n   * @attribute\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name\n   */\n  readonly eventBusName: string;\n\n  /**\n   * The ARN of this event bus resource\n   *\n   * @attribute\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Arn-fn::getatt\n   */\n  readonly eventBusArn: string;\n\n  /**\n   * The partner event source to associate with this event bus resource\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename\n   */\n  readonly eventSourceName?: string;\n\n  /**\n   * Create an EventBridge archive to send events to.\n   * When you create an archive, incoming events might not immediately start being sent to the archive.\n   * Allow a short period of time for changes to take effect.\n   *\n   * @param props Properties of the archive\n   */\n  archive(id: string, props: BaseArchiveProps): Archive;\n\n  /**\n   * Grants an IAM Principal to send custom events to the eventBus\n   * so that they can be matched to rules.\n   *\n   * @param grantee The principal (no-op if undefined)\n   */\n  grantPutEventsTo(grantee: iam.IGrantable): iam.Grant;\n}\n\n/**\n * Properties to define an event bus\n */\nexport interface EventBusProps extends AwsConstructProps {\n  /**\n   * The name of the event bus you are creating\n   * Note: If 'eventSourceName' is passed in, you cannot set this\n   *\n   * NOTE: the names of custom event buses can't contain the '/' character\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name\n   * @default - automatically generated name\n   */\n  readonly eventBusName?: string;\n\n  /**\n   * The partner event source to associate with this event bus resource\n   * Note: If 'eventBusName' is passed in, you cannot set this\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename\n   * @default - no partner event source\n   */\n  readonly eventSourceName?: string;\n\n  // TODO: Re-add KMS support\n  // /**\n  //  * The customer managed key that encrypt events on this event bus.\n  //  *\n  //  * @default - Use an AWS managed key\n  //  */\n  // readonly kmsKey?: encryption.IKey;\n\n  // // Description is not supported by terraform-provider-aws\n  // /**\n  //  * The event bus description.\n  //  *\n  //  * The description can be up to 512 characters long.\n  //  *\n  //  * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-description\n  //  *\n  //  * @default - no description\n  //  */\n  // readonly description?: string;\n}\n\n/**\n * Interface with properties necessary to import a reusable EventBus\n */\nexport interface EventBusAttributes {\n  /**\n   * The physical ID of this event bus resource\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-name\n   */\n  readonly eventBusName: string;\n\n  /**\n   * The ARN of this event bus resource\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#Arn-fn::getatt\n   */\n  readonly eventBusArn: string;\n\n  /**\n   * The partner event source to associate with this event bus resource\n   *\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html#cfn-events-eventbus-eventsourcename\n   * @default - no partner event source\n   */\n  readonly eventSourceName?: string;\n}\n\nabstract class EventBusBase extends AwsConstructBase implements IEventBus {\n  /**\n   * The physical ID of this event bus resource\n   */\n  public abstract readonly eventBusName: string;\n\n  /**\n   * The ARN of the event bus, such as:\n   * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.\n   */\n  public abstract readonly eventBusArn: string;\n\n  /**\n   * The name of the partner event source\n   */\n  public abstract readonly eventSourceName?: string;\n\n  public archive(id: string, props: BaseArchiveProps): Archive {\n    return new Archive(this, id, {\n      sourceEventBus: this,\n      description:\n        props.description || `Event Archive for ${this.eventBusName} Event Bus`,\n      eventPattern: props.eventPattern,\n      retention: props.retention,\n      archiveName: props.archiveName,\n    });\n  }\n\n  public grantPutEventsTo(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"events:PutEvents\"],\n      resourceArns: [this.eventBusArn],\n    });\n  }\n\n  public abstract addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult;\n}\n\n/**\n * Define an EventBridge EventBus\n *\n * @resource aws_cloudwatch_event_bus\n */\nexport class EventBus extends EventBusBase {\n  /**\n   * Import an existing event bus resource\n   * @param scope Parent construct\n   * @param id Construct ID\n   * @param eventBusArn ARN of imported event bus\n   */\n  public static fromEventBusArn(\n    scope: Construct,\n    id: string,\n    eventBusArn: string,\n  ): IEventBus {\n    const parts = AwsStack.ofAwsConstruct(scope).splitArn(\n      eventBusArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n\n    return new ImportedEventBus(scope, id, {\n      eventBusArn: eventBusArn,\n      eventBusName: parts.resourceName || \"\",\n    });\n  }\n\n  /**\n   * Import an existing event bus resource\n   * @param scope Parent construct\n   * @param id Construct ID\n   * @param eventBusName Name of imported event bus\n   */\n  public static fromEventBusName(\n    scope: Construct,\n    id: string,\n    eventBusName: string,\n  ): IEventBus {\n    const eventBusArn = AwsStack.ofAwsConstruct(scope).formatArn({\n      resource: \"event-bus\",\n      service: \"events\",\n      resourceName: eventBusName,\n    });\n\n    return EventBus.fromEventBusAttributes(scope, id, {\n      eventBusName: eventBusName,\n      eventBusArn: eventBusArn,\n    });\n  }\n\n  /**\n   * Import an existing event bus resource\n   * @param scope Parent construct\n   * @param id Construct ID\n   * @param attrs Imported event bus properties\n   */\n  public static fromEventBusAttributes(\n    scope: Construct,\n    id: string,\n    attrs: EventBusAttributes,\n  ): IEventBus {\n    return new ImportedEventBus(scope, id, attrs);\n  }\n\n  /**\n   * Permits an IAM Principal to send custom events to EventBridge\n   * so that they can be matched to rules.\n   *\n   * @param grantee The principal (no-op if undefined)\n   * @deprecated use grantAllPutEvents instead\n   */\n  public static grantPutEvents(grantee: iam.IGrantable): iam.Grant {\n    // It's currently not possible to restrict PutEvents to specific resources.\n    // See https://docs.aws.amazon.com/eventbridge/latest/userguide/permissions-reference-eventbridge.html\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"events:PutEvents\"],\n      resourceArns: [\"*\"],\n    });\n  }\n\n  /**\n   * Permits an IAM Principal to send custom events to EventBridge\n   * so that they can be matched to rules.\n   *\n   * @param grantee The principal (no-op if undefined)\n   */\n  public static grantAllPutEvents(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: [\"events:PutEvents\"],\n      resourceArns: [\"*\"],\n    });\n  }\n\n  private static eventBusProps(\n    defaultEventBusName: string,\n    props: EventBusProps = {},\n  ) {\n    const { eventBusName, eventSourceName } = props;\n    const eventBusNameRegex = /^[\\/\\.\\-_A-Za-z0-9]{1,256}$/;\n\n    if (eventBusName !== undefined && eventSourceName !== undefined) {\n      throw new Error(\n        \"'eventBusName' and 'eventSourceName' cannot both be provided\",\n      );\n    }\n\n    if (eventBusName !== undefined) {\n      if (!Token.isUnresolved(eventBusName)) {\n        if (eventBusName === \"default\") {\n          throw new Error(\"'eventBusName' must not be 'default'\");\n        } else if (eventBusName.indexOf(\"/\") > -1) {\n          throw new Error(\"'eventBusName' must not contain '/'\");\n        } else if (!eventBusNameRegex.test(eventBusName)) {\n          throw new Error(`'eventBusName' must satisfy: ${eventBusNameRegex}`);\n        }\n      }\n      return { eventBusName };\n    }\n\n    if (eventSourceName !== undefined) {\n      if (!Token.isUnresolved(eventSourceName)) {\n        // Ex: aws.partner/PartnerName/acct1/repo1\n        const eventSourceNameRegex = /^aws\\.partner(\\/[\\.\\-_A-Za-z0-9]+){2,}$/;\n        if (!eventSourceNameRegex.test(eventSourceName)) {\n          throw new Error(\n            `'eventSourceName' must satisfy: ${eventSourceNameRegex}`,\n          );\n        } else if (!eventBusNameRegex.test(eventSourceName)) {\n          throw new Error(\n            `'eventSourceName' must satisfy: ${eventBusNameRegex}`,\n          );\n        }\n      }\n      return { eventBusName: eventSourceName, eventSourceName };\n    }\n\n    return { eventBusName: defaultEventBusName };\n  }\n\n  public readonly resource: cloudwatchEventBus.CloudwatchEventBus;\n\n  public readonly eventBusOutputs: EventBusOutputs;\n  public get outputs(): Record<string, any> {\n    return this.eventBusOutputs;\n  }\n\n  private policy?: EventBusPolicy;\n\n  /**\n   * The physical ID of this event bus resource\n   */\n  public get eventBusName(): string {\n    return this.resource.name;\n  }\n\n  /**\n   * The ARN of the event bus, such as:\n   * arn:aws:events:us-east-2:123456789012:event-bus/aws.partner/PartnerName/acct1/repo1.\n   */\n  public get eventBusArn(): string {\n    return this.resource.arn;\n  }\n\n  /**\n   * The name of the partner event source\n   */\n  public readonly eventSourceName?: string;\n\n  constructor(scope: Construct, id: string, props?: EventBusProps) {\n    const { eventBusName, eventSourceName } = EventBus.eventBusProps(\n      // TODO(vincent): Figure out how this works...\n      Lazy.stringValue({ produce: () => AwsStack.uniqueId(this) }),\n      props,\n    );\n\n    super(scope, id, props);\n\n    // if (\n    //   props?.description &&\n    //   !Token.isUnresolved(props.description) &&\n    //   props.description.length > 512\n    // ) {\n    //   throw new Error(\n    //     `description must be less than or equal to 512 characters, got ${props.description.length}`,\n    //   );\n    // }\n\n    this.resource = new cloudwatchEventBus.CloudwatchEventBus(\n      this,\n      \"Resource\",\n      {\n        name: eventBusName,\n        eventSourceName,\n        // kmsKeyIdentifier: props?.kmsKey?.keyArn, // TODO: Re-add KMS support\n        // description: props?.description, // Description is not supported by terraform-provider-aws\n      },\n    );\n\n    // TODO: Re-add KMS support\n    // /**\n    //  * Allow EventBridge to use customer managed key\n    //  *\n    //  * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-encryption-key-policy.html#eb-encryption-key-policy-bus\n    //  */\n    // if (props?.kmsKey) {\n    //   props?.kmsKey.addToResourcePolicy(\n    //     new iam.PolicyStatement({\n    //       resources: [\"*\"],\n    //       actions: [\"kms:Decrypt\", \"kms:GenerateDataKey\", \"kms:DescribeKey\"],\n    //       principals: [new iam.ServicePrincipal(\"events.amazonaws.com\")],\n    //       conditions: {\n    //         StringEquals: {\n    //           \"aws:SourceAccount\": this.stack.account,\n    //           \"aws:SourceArn\": AwsStack.ofAwsConstruct(this).formatArn({\n    //             service: \"events\",\n    //             resource: \"event-bus\",\n    //             resourceName: eventBusName,\n    //           }),\n    //           \"kms:EncryptionContext:aws:events:event-bus:arn\": AwsStack.ofAwsConstruct(\n    //             this,\n    //           ).formatArn({\n    //             service: \"events\",\n    //             resource: \"event-bus\",\n    //             resourceName: eventBusName,\n    //           }),\n    //         },\n    //       },\n    //     }),\n    //   );\n    // }\n\n    this.eventSourceName = this.resource.eventSourceName;\n    this.eventBusOutputs = {\n      name: this.eventBusName,\n      arn: this.eventBusArn,\n      eventSourceName: this.eventSourceName,\n    };\n  }\n\n  /**\n   * Adds a statement to the IAM resource policy associated with this event bus.\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.policy) {\n      this.policy = new EventBusPolicy(this, \"Policy\", { eventBus: this });\n    }\n\n    if (this.policy) {\n      this.policy.document.addStatements(statement);\n      return { statementAdded: true, policyDependable: this.policy };\n    }\n\n    return { statementAdded: false };\n  }\n}\n\nclass ImportedEventBus extends EventBusBase {\n  public readonly eventBusArn: string;\n  public readonly eventBusName: string;\n  public readonly eventSourceName?: string;\n  public readonly eventBusOutputs: EventBusOutputs;\n  public get outputs() {\n    return this.eventBusOutputs;\n  }\n\n  constructor(scope: Construct, id: string, attrs: EventBusAttributes) {\n    const arnParts = AwsStack.ofAwsConstruct(scope).splitArn(\n      attrs.eventBusArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n    super(scope, id, {\n      account: arnParts.account,\n      region: arnParts.region,\n    });\n\n    this.eventBusArn = attrs.eventBusArn;\n    this.eventBusName = attrs.eventBusName;\n    this.eventSourceName = attrs.eventSourceName;\n    this.eventBusOutputs = {\n      name: this.eventBusName,\n      arn: this.eventBusArn,\n      eventSourceName: this.eventSourceName,\n    };\n  }\n\n  public addToResourcePolicy(\n    _statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    throw new Error(\n      [\n        \"Cannot add a statement to an imported EventBus. You may use `EventBridgePermission` instead.\",\n        \"If the EventBus already has a policy attached, the permissions will be overwritten.\",\n      ].join(\"\\n\"),\n    );\n  }\n}\n\n/**\n * Properties to associate Event Buses with a policy\n */\nexport interface EventBusPolicyProps extends AwsConstructProps {\n  /**\n   * The event bus to which the policy applies\n   */\n  readonly eventBus: IEventBus;\n}\n\n/**\n * The policy for an Event Bus\n *\n * Policies define the operations that are allowed on this resource.\n *\n * You almost never need to define this construct directly.\n *\n * The EventBusPolicy resource (`aws_cloudwatch_event_bus_policy`)\n * is incompatible with the EventBridgePermission resource (`aws_cloudwatch_event_permission`)\n * and will overwrite permissions.\n *\n * All AWS resources that support resource policies have a method called\n * `addToResourcePolicy()`, which will automatically create a new resource\n * policy if one doesn't exist yet, otherwise it will add to the existing\n * policy.\n *\n * Prefer to use `addToResourcePolicy()` instead.\n *\n * @resource aws_cloudwatch_event_bus_policy\n */\nexport class EventBusPolicy extends AwsConstructBase {\n  /**\n   * The IAM policy document for this policy.\n   */\n  public readonly document: iam.PolicyDocument;\n  public get outputs(): Record<string, any> {\n    return this.document.outputs;\n  }\n  constructor(scope: Construct, id: string, props: EventBusPolicyProps) {\n    super(scope, id, props);\n    this.document = new iam.PolicyDocument(this, \"Document\");\n\n    new cloudwatchEventBusPolicy.CloudwatchEventBusPolicy(this, \"Resource\", {\n      // https://github.com/hashicorp/terraform-provider-aws/pull/16874#discussion_r656024830\n      policy: this.document.json,\n      eventBusName: props.eventBus.eventBusName,\n    });\n  }\n}\n\n/**\n * Properties to add permissions to an Event Bus\n */\nexport interface EventBridgePermissionProps extends AwsConstructProps {\n  // TODO: Auto generate this using struct builder to keep docs updated?\n  /**\n   * The event bus to which the policy applies\n   */\n  readonly eventBus: IEventBus;\n  /**\n   * An identifier string for the external account that\n   * you are granting permissions to.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#statement_id CloudwatchEventPermission#statement_id}\n   */\n  readonly statementId: string;\n  /**\n   * The action that you are enabling the other account to perform. Defaults to events:PutEvents\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#action CloudwatchEventPermission#action}\n   * @default \"events:PutEvents\"\n   */\n  readonly action?: string;\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#event_bus_name CloudwatchEventPermission#event_bus_name}\n   */\n  readonly eventBusName?: string;\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#id CloudwatchEventPermission#id}\n   *\n   * Please be aware that the id field is automatically added to all resources in Terraform providers using a Terraform provider SDK version below 2.\n   * If you experience problems setting this value it might not be settable. Please take a look at the provider documentation to ensure it should be settable.\n   */\n  readonly id?: string;\n  /**\n   * The 12-digit AWS account ID that you are permitting to put events to your default event bus.\n   * Specify * to permit any account to put events to your default event bus, optionally limited\n   * by condition.\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#principal CloudwatchEventPermission#principal}\n   */\n  readonly principal: string;\n  /**\n   * Configuration block to limit the event bus permissions you are granting to only accounts that\n   * fulfill the condition.condition block\n   *\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/cloudwatch_event_permission#condition CloudwatchEventPermission#condition}\n   */\n  readonly condition?: cloudwatchEventPermission.CloudwatchEventPermissionCondition;\n}\n\n/**\n * A single permission for an Event Bus\n *\n * All AWS resources that support resource policies have a method called\n * `addToResourcePolicy()`, which will automatically create a new resource\n * policy if one doesn't exist yet, otherwise it will add to the existing\n * policy.\n *\n * If `addToResourcePolicy()` was used on the event bus, The EventBusPolicy resource\n * (`aws_cloudwatch_event_bus_policy`) is incompatible with this resource and\n * will overwrite permissions.\n *\n * @resource aws_cloudwatch_event_permission\n */\nexport class EventBridgePermission extends AwsConstructBase {\n  public get outputs(): Record<string, any> {\n    return {};\n  }\n  constructor(scope: Construct, id: string, props: EventBridgePermissionProps) {\n    super(scope, id, props);\n\n    new cloudwatchEventPermission.CloudwatchEventPermission(this, \"Resource\", {\n      // https://github.com/hashicorp/terraform-provider-aws/pull/16874#discussion_r656024830\n      ...props,\n      eventBusName: props.eventBus.eventBusName,\n    });\n  }\n}\n"]}

package/lib/aws/notify/event-pattern.d.ts

@@ -0,0 +1,220 @@
+import { IResolvable, IResolveContext } from "cdktf";
+/**
+ * An event pattern matcher
+ */
+export declare class Match implements IResolvable {
+    private readonly matchers;
+    private readonly options;
+    /**
+     * Matches a null value in the JSON of the event
+     */
+    static nullValue(): string[];
+    /**
+     * Matches when the field is present in the JSON of the event
+     */
+    static exists(): string[];
+    /**
+     * Matches when the field is absent from the JSON of the event
+     */
+    static doesNotExist(): string[];
+    /**
+     * Matches a string, exactly, in the JSON of the event
+     */
+    static exactString(value: string): string[];
+    /**
+     * Matches a string, regardless of case, in the JSON of the event
+     */
+    static equalsIgnoreCase(value: string): string[];
+    /**
+     * Matches strings with the given prefix in the JSON of the event
+     */
+    static prefix(value: string): string[];
+    /**
+     * Matches strings with the given suffix in the JSON of the event
+     */
+    static suffix(value: string): string[];
+    /**
+     * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format
+     */
+    static cidr(range: string): string[];
+    /**
+     * Matches IPv4 and IPv6 network addresses using the Classless Inter-Domain Routing (CIDR) format.
+     * Alias of `cidr()`.
+     */
+    static ipAddressRange(range: string): string[];
+    /**
+     * Matches anything except what's provided in the rule. The list of provided values must contain
+     * only strings or only numbers.
+     */
+    static anythingBut(...values: any[]): string[];
+    /**
+     * Matches any string that doesn't start with the given prefix.
+     */
+    static anythingButPrefix(prefix: string): string[];
+    /**
+     * Matches numbers greater than the provided value
+     */
+    static greaterThan(value: number): string[];
+    /**
+     * Matches numbers greater than, or equal to, the provided value
+     */
+    static greaterThanOrEqual(value: number): string[];
+    /**
+     * Matches numbers less than the provided value
+     */
+    static lessThan(value: number): string[];
+    /**
+     * Matches numbers less than, or equal to, the provided value
+     */
+    static lessThanOrEqual(value: number): string[];
+    /**
+     * Matches numbers equal to the provided value
+     */
+    static equal(value: number): string[];
+    /**
+     * Matches numbers inside a closed numeric interval. Equivalent to:
+     *
+     *    Match.allOf(Match.greaterThanOrEqual(lower), Match.lessThanOrEqual(upper))
+     *
+     * @param lower Lower bound (inclusive)
+     * @param upper Upper bound (inclusive)
+     */
+    static interval(lower: number, upper: number): string[];
+    /**
+     * Matches an event if any of the provided matchers do. Only numeric matchers are accepted.
+     */
+    static allOf(...matchers: any[]): string[];
+    /**
+     * Matches an event if any of the provided matchers does.
+     */
+    static anyOf(...matchers: any[]): string[];
+    private static numeric;
+    private static fromObjects;
+    private static fromMergedObjects;
+    readonly creationStack: string[];
+    private constructor();
+    resolve(context: IResolveContext): any;
+    private merge;
+    toString(): string;
+    /**
+     * A representation of this matcher as a list of strings
+     */
+    asList(): string[];
+}
+/**
+ * Events in Amazon CloudWatch Events are represented as JSON objects. For more
+ * information about JSON objects, see RFC 7159.
+ *
+ * **Important**: this class can only be used with a `Rule` class. In particular,
+ * do not use it with `CfnRule` class: your pattern will not be rendered
+ * correctly. In a `CfnRule` class, write the pattern as you normally would when
+ * directly writing CloudFormation.
+ *
+ * Rules use event patterns to select events and route them to targets. A
+ * pattern either matches an event or it doesn't. Event patterns are represented
+ * as JSON objects with a structure that is similar to that of events.
+ *
+ * It is important to remember the following about event pattern matching:
+ *
+ * - For a pattern to match an event, the event must contain all the field names
+ *   listed in the pattern. The field names must appear in the event with the
+ *   same nesting structure.
+ *
+ * - Other fields of the event not mentioned in the pattern are ignored;
+ *   effectively, there is a ``"*": "*"`` wildcard for fields not mentioned.
+ *
+ * - The matching is exact (character-by-character), without case-folding or any
+ *   other string normalization.
+ *
+ * - The values being matched follow JSON rules: Strings enclosed in quotes,
+ *   numbers, and the unquoted keywords true, false, and null.
+ *
+ * - Number matching is at the string representation level. For example, 300,
+ *   300.0, and 3.0e2 are not considered equal.
+ *
+ * For custom events, some optional properties are required. For more information, see
+ * [Minimum information needed for a valid custom event](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-events-structure.html#eb-custom-event).
+ *
+ * @see https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CloudWatchEventsandEventPatterns.html
+ */
+export interface EventPattern {
+    /**
+     * By default, this is set to 0 (zero) in all events.
+     *
+     * @default - No filtering on version
+     */
+    readonly version?: string[];
+    /**
+     * A unique value is generated for every event. This can be helpful in
+     * tracing events as they move through rules to targets, and are processed.
+     *
+     * @default - No filtering on id
+     */
+    readonly id?: string[];
+    /**
+     * Identifies, in combination with the source field, the fields and values
+     * that appear in the detail field.
+     *
+     * Represents the "detail-type" event field.
+     *
+     * @default - No filtering on detail type
+     */
+    readonly detailType?: string[];
+    /**
+     * Identifies the service that sourced the event. All events sourced from
+     * within AWS begin with "aws." Customer-generated events can have any value
+     * here, as long as it doesn't begin with "aws." We recommend the use of
+     * Java package-name style reverse domain-name strings.
+     *
+     * To find the correct value for source for an AWS service, see the table in
+     * AWS Service Namespaces. For example, the source value for Amazon
+     * CloudFront is aws.cloudfront.
+     *
+     * @see http://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#genref-aws-service-namespaces
+     * @default - No filtering on source
+     */
+    readonly source?: string[];
+    /**
+     * The 12-digit number identifying an AWS account.
+     *
+     * @default - No filtering on account
+     */
+    readonly account?: string[];
+    /**
+     * The event timestamp, which can be specified by the service originating
+     * the event. If the event spans a time interval, the service might choose
+     * to report the start time, so this value can be noticeably before the time
+     * the event is actually received.
+     *
+     * @default - No filtering on time
+     */
+    readonly time?: string[];
+    /**
+     * Identifies the AWS region where the event originated.
+     *
+     * @default - No filtering on region
+     */
+    readonly region?: string[];
+    /**
+     * This JSON array contains ARNs that identify resources that are involved
+     * in the event. Inclusion of these ARNs is at the discretion of the
+     * service.
+     *
+     * For example, Amazon EC2 instance state-changes include Amazon EC2
+     * instance ARNs, Auto Scaling events include ARNs for both instances and
+     * Auto Scaling groups, but API calls with AWS CloudTrail do not include
+     * resource ARNs.
+     *
+     * @default - No filtering on resource
+     */
+    readonly resources?: string[];
+    /**
+     * A JSON object, whose content is at the discretion of the service
+     * originating the event.
+     *
+     * @default - No filtering on detail
+     */
+    readonly detail?: {
+        [key: string]: any;
+    };
+}