terraconstructs 0.0.17 → 0.0.18

package/lib/aws/notify/kinesis-stream.js

@@ -494,7 +494,7 @@ class Stream extends StreamBase {
 }
 exports.Stream = Stream;
 _a = JSII_RTTI_SYMBOL_1;
-Stream[_a] = { fqn: "terraconstructs.aws.notify.Stream", version: "0.0.17" };
+Stream[_a] = { fqn: "terraconstructs.aws.notify.Stream", version: "0.0.18" };
 /**
  * What kind of server-side encryption to apply to this stream
  */

package/lib/aws/notify/notification-rule-source.d.ts

@@ -0,0 +1,20 @@
+import * as constructs from "constructs";
+/**
+ * Information about the Codebuild or CodePipeline associated with a notification source.
+ */
+export interface NotificationRuleSourceConfig {
+    /**
+     * The Amazon Resource Name (ARN) of the notification source.
+     */
+    readonly sourceArn: string;
+}
+/**
+ * Represents a notification source
+ * The source that allows CodeBuild and CodePipeline to associate with this rule.
+ */
+export interface INotificationRuleSource {
+    /**
+     * Returns a source configuration for notification rule.
+     */
+    bindAsNotificationRuleSource(scope: constructs.Construct): NotificationRuleSourceConfig;
+}

package/lib/aws/notify/notification-rule-source.js

@@ -0,0 +1,4 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/a2c633f1e698249496f11338312ab42bd7b1e4f0/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule-source.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLXJ1bGUtc291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9ub3RpZnkvbm90aWZpY2F0aW9uLXJ1bGUtc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw4SkFBOEoiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi9hMmM2MzNmMWU2OTgyNDk0OTZmMTEzMzgzMTJhYjQyYmQ3YjFlNGYwL3BhY2thZ2VzL2F3cy1jZGstbGliL2F3cy1jb2Rlc3Rhcm5vdGlmaWNhdGlvbnMvbGliL25vdGlmaWNhdGlvbi1ydWxlLXNvdXJjZS50c1xuXG5pbXBvcnQgKiBhcyBjb25zdHJ1Y3RzIGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5cbi8qKlxuICogSW5mb3JtYXRpb24gYWJvdXQgdGhlIENvZGVidWlsZCBvciBDb2RlUGlwZWxpbmUgYXNzb2NpYXRlZCB3aXRoIGEgbm90aWZpY2F0aW9uIHNvdXJjZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBOb3RpZmljYXRpb25SdWxlU291cmNlQ29uZmlnIHtcbiAgLyoqXG4gICAqIFRoZSBBbWF6b24gUmVzb3VyY2UgTmFtZSAoQVJOKSBvZiB0aGUgbm90aWZpY2F0aW9uIHNvdXJjZS5cbiAgICovXG4gIHJlYWRvbmx5IHNvdXJjZUFybjogc3RyaW5nO1xufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBub3RpZmljYXRpb24gc291cmNlXG4gKiBUaGUgc291cmNlIHRoYXQgYWxsb3dzIENvZGVCdWlsZCBhbmQgQ29kZVBpcGVsaW5lIHRvIGFzc29jaWF0ZSB3aXRoIHRoaXMgcnVsZS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBJTm90aWZpY2F0aW9uUnVsZVNvdXJjZSB7XG4gIC8qKlxuICAgKiBSZXR1cm5zIGEgc291cmNlIGNvbmZpZ3VyYXRpb24gZm9yIG5vdGlmaWNhdGlvbiBydWxlLlxuICAgKi9cbiAgYmluZEFzTm90aWZpY2F0aW9uUnVsZVNvdXJjZShcbiAgICBzY29wZTogY29uc3RydWN0cy5Db25zdHJ1Y3QsXG4gICk6IE5vdGlmaWNhdGlvblJ1bGVTb3VyY2VDb25maWc7XG59XG4iXX0=

package/lib/aws/notify/notification-rule-target.d.ts

@@ -0,0 +1,24 @@
+import * as constructs from "constructs";
+/**
+ * Information about the SNS topic or AWS Chatbot client associated with a notification target.
+ */
+export interface NotificationRuleTargetConfig {
+    /**
+     * The target type. Can be an Amazon SNS topic or AWS Chatbot client.
+     */
+    readonly targetType: string;
+    /**
+     * The Amazon Resource Name (ARN) of the Amazon SNS topic or AWS Chatbot client.
+     */
+    readonly targetAddress: string;
+}
+/**
+ * Represents a notification target
+ * That allows AWS Chatbot and SNS topic to associate with this rule target.
+ */
+export interface INotificationRuleTarget {
+    /**
+     * Returns a target configuration for notification rule.
+     */
+    bindAsNotificationRuleTarget(scope: constructs.Construct): NotificationRuleTargetConfig;
+}

package/lib/aws/notify/notification-rule-target.js

@@ -0,0 +1,4 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/a2c633f1e698249496f11338312ab42bd7b1e4f0/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule-target.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLXJ1bGUtdGFyZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2F3cy9ub3RpZnkvbm90aWZpY2F0aW9uLXJ1bGUtdGFyZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw4SkFBOEoiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBodHRwczovL2dpdGh1Yi5jb20vYXdzL2F3cy1jZGsvYmxvYi9hMmM2MzNmMWU2OTgyNDk0OTZmMTEzMzgzMTJhYjQyYmQ3YjFlNGYwL3BhY2thZ2VzL2F3cy1jZGstbGliL2F3cy1jb2Rlc3Rhcm5vdGlmaWNhdGlvbnMvbGliL25vdGlmaWNhdGlvbi1ydWxlLXRhcmdldC50c1xuXG5pbXBvcnQgKiBhcyBjb25zdHJ1Y3RzIGZyb20gXCJjb25zdHJ1Y3RzXCI7XG5cbi8qKlxuICogSW5mb3JtYXRpb24gYWJvdXQgdGhlIFNOUyB0b3BpYyBvciBBV1MgQ2hhdGJvdCBjbGllbnQgYXNzb2NpYXRlZCB3aXRoIGEgbm90aWZpY2F0aW9uIHRhcmdldC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBOb3RpZmljYXRpb25SdWxlVGFyZ2V0Q29uZmlnIHtcbiAgLyoqXG4gICAqIFRoZSB0YXJnZXQgdHlwZS4gQ2FuIGJlIGFuIEFtYXpvbiBTTlMgdG9waWMgb3IgQVdTIENoYXRib3QgY2xpZW50LlxuICAgKi9cbiAgcmVhZG9ubHkgdGFyZ2V0VHlwZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgQW1hem9uIFJlc291cmNlIE5hbWUgKEFSTikgb2YgdGhlIEFtYXpvbiBTTlMgdG9waWMgb3IgQVdTIENoYXRib3QgY2xpZW50LlxuICAgKi9cbiAgcmVhZG9ubHkgdGFyZ2V0QWRkcmVzczogc3RyaW5nO1xufVxuXG4vKipcbiAqIFJlcHJlc2VudHMgYSBub3RpZmljYXRpb24gdGFyZ2V0XG4gKiBUaGF0IGFsbG93cyBBV1MgQ2hhdGJvdCBhbmQgU05TIHRvcGljIHRvIGFzc29jaWF0ZSB3aXRoIHRoaXMgcnVsZSB0YXJnZXQuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSU5vdGlmaWNhdGlvblJ1bGVUYXJnZXQge1xuICAvKipcbiAgICogUmV0dXJucyBhIHRhcmdldCBjb25maWd1cmF0aW9uIGZvciBub3RpZmljYXRpb24gcnVsZS5cbiAgICovXG4gIGJpbmRBc05vdGlmaWNhdGlvblJ1bGVUYXJnZXQoXG4gICAgc2NvcGU6IGNvbnN0cnVjdHMuQ29uc3RydWN0LFxuICApOiBOb3RpZmljYXRpb25SdWxlVGFyZ2V0Q29uZmlnO1xufVxuIl19

package/lib/aws/notify/notification-rule.d.ts

@@ -0,0 +1,123 @@
+import * as constructs from "constructs";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "..";
+import { INotificationRuleSource } from "./notification-rule-source";
+import { INotificationRuleTarget } from "./notification-rule-target";
+/**
+ * The level of detail to include in the notifications for this resource.
+ */
+export declare enum DetailType {
+    /**
+     * BASIC will include only the contents of the event as it would appear in AWS CloudWatch
+     */
+    BASIC = "BASIC",
+    /**
+     * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
+     */
+    FULL = "FULL"
+}
+/**
+ * Standard set of options for `notifyOnXxx` codestar notification handler on construct
+ */
+export interface NotificationRuleOptions {
+    /**
+     * The name for the notification rule.
+     * Notification rule names must be unique in your AWS account.
+     *
+     * @default - generated from the `id`
+     */
+    readonly notificationRuleName?: string;
+    /**
+     * The status of the notification rule.
+     * If the enabled is set to DISABLED, notifications aren't sent for the notification rule.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * The level of detail to include in the notifications for this resource.
+     * BASIC will include only the contents of the event as it would appear in AWS CloudWatch.
+     * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
+     *
+     * @default DetailType.FULL
+     */
+    readonly detailType?: DetailType;
+}
+/**
+ * Properties for a new notification rule
+ */
+export interface NotificationRuleProps extends AwsConstructProps, NotificationRuleOptions {
+    /**
+     * A list of event types associated with this notification rule.
+     * For a complete list of event types and IDs, see Notification concepts in the Developer Tools Console User Guide.
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#concepts-api
+     */
+    readonly events: string[];
+    /**
+     * The Amazon Resource Name (ARN) of the resource to associate with the notification rule.
+     * Currently, Supported sources include pipelines in AWS CodePipeline, build projects in AWS CodeBuild, and repositories in AWS CodeCommit in this L2 constructor.
+     * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarnotifications-notificationrule.html#cfn-codestarnotifications-notificationrule-resource
+     */
+    readonly source: INotificationRuleSource;
+    /**
+     * The targets to register for the notification destination.
+     *
+     * @default - No targets are added to the rule. Use `addTarget()` to add a target.
+     */
+    readonly targets?: INotificationRuleTarget[];
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/codestarnotifications_notification_rule#tags CodestarnotificationsNotificationRule#tags}
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Represents a notification rule
+ */
+export interface INotificationRule extends IAwsConstruct {
+    /**
+     * The ARN of the notification rule (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)
+     *
+     * @attribute
+     */
+    readonly notificationRuleArn: string;
+    /**
+     * Adds target to notification rule
+     *
+     * @param target The SNS topic or AWS Chatbot Slack target
+     * @returns boolean - return true if it had any effect
+     */
+    addTarget(target: INotificationRuleTarget): boolean;
+}
+/**
+ * A new notification rule
+ *
+ * @resource AWS::CodeStarNotifications::NotificationRule
+ */
+export declare class NotificationRule extends AwsConstructBase implements INotificationRule {
+    /**
+     * Import an existing notification rule provided an ARN
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param notificationRuleArn Notification rule ARN (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)
+     */
+    static fromNotificationRuleArn(scope: constructs.Construct, id: string, notificationRuleArn: string): INotificationRule;
+    /**
+     * @attribute
+     */
+    readonly notificationRuleArn: string;
+    private readonly targetList;
+    private readonly events;
+    private readonly resource;
+    get outputs(): Record<string, any>;
+    constructor(scope: constructs.Construct, id: string, props: NotificationRuleProps);
+    addTarget(target: INotificationRuleTarget): boolean;
+    /**
+     * Adds events to notification rule
+     *
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-buildproject
+     * @param events The list of event types for AWS Codebuild and AWS CodePipeline
+     */
+    private addEvents;
+}

package/lib/aws/notify/notification-rule.js

@@ -0,0 +1,129 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationRule = exports.DetailType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/bc96ee17a18c19b98e4ad052bed7c24da2371050/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+/**
+ * The level of detail to include in the notifications for this resource.
+ */
+var DetailType;
+(function (DetailType) {
+    /**
+     * BASIC will include only the contents of the event as it would appear in AWS CloudWatch
+     */
+    DetailType["BASIC"] = "BASIC";
+    /**
+     * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
+     */
+    DetailType["FULL"] = "FULL";
+})(DetailType || (exports.DetailType = DetailType = {}));
+/**
+ * A new notification rule
+ *
+ * @resource AWS::CodeStarNotifications::NotificationRule
+ */
+class NotificationRule extends __1.AwsConstructBase {
+    /**
+     * Import an existing notification rule provided an ARN
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param notificationRuleArn Notification rule ARN (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)
+     */
+    static fromNotificationRuleArn(scope, id, notificationRuleArn) {
+        class Import extends __1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.notificationRuleArn = notificationRuleArn;
+            }
+            get outputs() {
+                return { notificationRuleArn: this.notificationRuleArn };
+            }
+            addTarget(_target) {
+                cdktf_1.Annotations.of(this).addWarning(`Cannot add targets to imported NotificationRule '${this.node.id}'. Define targets directly on the source or manage permissions separately.`);
+                return false;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: notificationRuleArn,
+        });
+    }
+    get outputs() {
+        return { notificationRuleArn: this.notificationRuleArn };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.targetList = [];
+        this.events = [];
+        const source = props.source.bindAsNotificationRuleSource(this);
+        this.addEvents(props.events);
+        // Process initial targets from props
+        props.targets?.forEach((target) => {
+            this.addTarget(target);
+        });
+        const ruleName = props.notificationRuleName
+            ? props.notificationRuleName.slice(-64) // Ensure 64 char limit
+            : this.stack.uniqueResourceName(this, { maxLength: 64 });
+        this.resource =
+            new provider_aws_1.codestarnotificationsNotificationRule.CodestarnotificationsNotificationRule(this, "Resource", {
+                name: ruleName,
+                detailType: props.detailType ?? DetailType.FULL,
+                eventTypeIds: cdktf_1.Lazy.listValue({
+                    produce: () => {
+                        if (cdktf_1.Token.isUnresolved(props.events)) {
+                            return props.events;
+                        }
+                        return this.events;
+                    },
+                }),
+                resource: source.sourceArn,
+                status: props.enabled === false
+                    ? "DISABLED"
+                    : props.enabled === true || props.enabled === undefined
+                        ? "ENABLED"
+                        : undefined, // Let Terraform handle default if undefined
+                // Use Lazy producer to handle the potentially dynamic list of targets
+                target: cdktf_1.Lazy.anyValue({
+                    produce: () => this.targetList.map((t) => provider_aws_1.codestarnotificationsNotificationRule.codestarnotificationsNotificationRuleTargetToTerraform({
+                        address: t.targetAddress,
+                        type: t.targetType,
+                    })),
+                }),
+                tags: props.tags,
+            });
+        this.notificationRuleArn = this.resource.arn;
+    }
+    addTarget(target) {
+        const boundTarget = target.bindAsNotificationRuleTarget(this);
+        // Check if target already exists to avoid duplicates if this method were to update the resource
+        const exists = this.targetList.some((t) => t.targetAddress === boundTarget.targetAddress &&
+            t.targetType === boundTarget.targetType);
+        if (!exists) {
+            this.targetList.push(boundTarget);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Adds events to notification rule
+     *
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
+     * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-buildproject
+     * @param events The list of event types for AWS Codebuild and AWS CodePipeline
+     */
+    addEvents(events) {
+        events.forEach((event) => {
+            if (this.events.includes(event)) {
+                return;
+            }
+            this.events.push(event);
+        });
+    }
+}
+exports.NotificationRule = NotificationRule;
+_a = JSII_RTTI_SYMBOL_1;
+NotificationRule[_a] = { fqn: "terraconstructs.aws.notify.NotificationRule", version: "0.0.18" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-rule.js","sourceRoot":"","sources":["../../../src/aws/notify/notification-rule.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/bc96ee17a18c19b98e4ad052bed7c24da2371050/packages/aws-cdk-lib/aws-codestarnotifications/lib/notification-rule.ts\n\nimport { codestarnotificationsNotificationRule } from \"@cdktf/provider-aws\";\nimport { Annotations, Lazy, Token } from \"cdktf\";\nimport * as constructs from \"constructs\";\nimport { AwsConstructBase, AwsConstructProps, IAwsConstruct } from \"..\";\nimport { INotificationRuleSource } from \"./notification-rule-source\";\nimport {\n  INotificationRuleTarget,\n  NotificationRuleTargetConfig,\n} from \"./notification-rule-target\";\n\n/**\n * The level of detail to include in the notifications for this resource.\n */\nexport enum DetailType {\n  /**\n   * BASIC will include only the contents of the event as it would appear in AWS CloudWatch\n   */\n  BASIC = \"BASIC\",\n\n  /**\n   * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.\n   */\n  FULL = \"FULL\",\n}\n\n/**\n * Standard set of options for `notifyOnXxx` codestar notification handler on construct\n */\nexport interface NotificationRuleOptions {\n  /**\n   * The name for the notification rule.\n   * Notification rule names must be unique in your AWS account.\n   *\n   * @default - generated from the `id`\n   */\n  readonly notificationRuleName?: string;\n\n  /**\n   * The status of the notification rule.\n   * If the enabled is set to DISABLED, notifications aren't sent for the notification rule.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The level of detail to include in the notifications for this resource.\n   * BASIC will include only the contents of the event as it would appear in AWS CloudWatch.\n   * FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.\n   *\n   * @default DetailType.FULL\n   */\n  readonly detailType?: DetailType;\n\n  // createdBy is not supported by the Terraform resource\n  // /**\n  //  * The name or email alias of the person who created the notification rule.\n  //  * If not specified, it means that the creator's alias is not provided.\n  //  *\n  //  * @default - No alias provided\n  //  */\n  // readonly createdBy?: string;\n}\n\n/**\n * Properties for a new notification rule\n */\nexport interface NotificationRuleProps\n  extends AwsConstructProps,\n    NotificationRuleOptions {\n  /**\n   * A list of event types associated with this notification rule.\n   * For a complete list of event types and IDs, see Notification concepts in the Developer Tools Console User Guide.\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#concepts-api\n   */\n  readonly events: string[];\n\n  /**\n   * The Amazon Resource Name (ARN) of the resource to associate with the notification rule.\n   * Currently, Supported sources include pipelines in AWS CodePipeline, build projects in AWS CodeBuild, and repositories in AWS CodeCommit in this L2 constructor.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarnotifications-notificationrule.html#cfn-codestarnotifications-notificationrule-resource\n   */\n  readonly source: INotificationRuleSource;\n\n  /**\n   * The targets to register for the notification destination.\n   *\n   * @default - No targets are added to the rule. Use `addTarget()` to add a target.\n   */\n  readonly targets?: INotificationRuleTarget[];\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.88.0/docs/resources/codestarnotifications_notification_rule#tags CodestarnotificationsNotificationRule#tags}\n   */\n  readonly tags?: {\n    [key: string]: string;\n  };\n}\n\n/**\n * Represents a notification rule\n */\nexport interface INotificationRule extends IAwsConstruct {\n  /**\n   * The ARN of the notification rule (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)\n   *\n   * @attribute\n   */\n  readonly notificationRuleArn: string;\n\n  /**\n   * Adds target to notification rule\n   *\n   * @param target The SNS topic or AWS Chatbot Slack target\n   * @returns boolean - return true if it had any effect\n   */\n  addTarget(target: INotificationRuleTarget): boolean;\n}\n\n/**\n * A new notification rule\n *\n * @resource AWS::CodeStarNotifications::NotificationRule\n */\nexport class NotificationRule\n  extends AwsConstructBase\n  implements INotificationRule\n{\n  /**\n   * Import an existing notification rule provided an ARN\n   * @param scope The parent creating construct\n   * @param id The construct's name\n   * @param notificationRuleArn Notification rule ARN (i.e. arn:aws:codestar-notifications:::notificationrule/01234abcde)\n   */\n  public static fromNotificationRuleArn(\n    scope: constructs.Construct,\n    id: string,\n    notificationRuleArn: string,\n  ): INotificationRule {\n    class Import extends AwsConstructBase implements INotificationRule {\n      readonly notificationRuleArn = notificationRuleArn;\n      public get outputs(): Record<string, any> {\n        return { notificationRuleArn: this.notificationRuleArn };\n      }\n\n      public addTarget(_target: INotificationRuleTarget): boolean {\n        Annotations.of(this).addWarning(\n          `Cannot add targets to imported NotificationRule '${this.node.id}'. Define targets directly on the source or manage permissions separately.`,\n        );\n        return false;\n      }\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: notificationRuleArn,\n    });\n  }\n\n  /**\n   * @attribute\n   */\n  public readonly notificationRuleArn: string;\n\n  private readonly targetList: NotificationRuleTargetConfig[] = [];\n  private readonly events: string[] = [];\n  private readonly resource: codestarnotificationsNotificationRule.CodestarnotificationsNotificationRule;\n\n  public get outputs(): Record<string, any> {\n    return { notificationRuleArn: this.notificationRuleArn };\n  }\n\n  constructor(\n    scope: constructs.Construct,\n    id: string,\n    props: NotificationRuleProps,\n  ) {\n    super(scope, id, props);\n\n    const source = props.source.bindAsNotificationRuleSource(this);\n\n    this.addEvents(props.events);\n\n    // Process initial targets from props\n    props.targets?.forEach((target) => {\n      this.addTarget(target);\n    });\n\n    const ruleName = props.notificationRuleName\n      ? props.notificationRuleName.slice(-64) // Ensure 64 char limit\n      : this.stack.uniqueResourceName(this, { maxLength: 64 });\n\n    this.resource =\n      new codestarnotificationsNotificationRule.CodestarnotificationsNotificationRule(\n        this,\n        \"Resource\",\n        {\n          name: ruleName,\n          detailType: props.detailType ?? DetailType.FULL,\n          eventTypeIds: Lazy.listValue({\n            produce: () => {\n              if (Token.isUnresolved(props.events)) {\n                return props.events;\n              }\n              return this.events;\n            },\n          }),\n          resource: source.sourceArn,\n          status:\n            props.enabled === false\n              ? \"DISABLED\"\n              : props.enabled === true || props.enabled === undefined\n                ? \"ENABLED\"\n                : undefined, // Let Terraform handle default if undefined\n          // Use Lazy producer to handle the potentially dynamic list of targets\n          target: Lazy.anyValue({\n            produce: () =>\n              this.targetList.map((t) =>\n                codestarnotificationsNotificationRule.codestarnotificationsNotificationRuleTargetToTerraform(\n                  {\n                    address: t.targetAddress,\n                    type: t.targetType,\n                  },\n                ),\n              ),\n          }),\n          tags: props.tags,\n        },\n      );\n\n    this.notificationRuleArn = this.resource.arn;\n  }\n\n  public addTarget(target: INotificationRuleTarget): boolean {\n    const boundTarget = target.bindAsNotificationRuleTarget(this);\n    // Check if target already exists to avoid duplicates if this method were to update the resource\n    const exists = this.targetList.some(\n      (t) =>\n        t.targetAddress === boundTarget.targetAddress &&\n        t.targetType === boundTarget.targetType,\n    );\n    if (!exists) {\n      this.targetList.push(boundTarget);\n      return true;\n    }\n    return false;\n  }\n  /**\n   * Adds events to notification rule\n   *\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline\n   * @see https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-buildproject\n   * @param events The list of event types for AWS Codebuild and AWS CodePipeline\n   */\n  private addEvents(events: string[]): void {\n    events.forEach((event) => {\n      if (this.events.includes(event)) {\n        return;\n      }\n\n      this.events.push(event);\n    });\n  }\n}\n"]}

package/lib/aws/notify/policy.d.ts

@@ -0,0 +1,56 @@
+import { Construct } from "constructs";
+import { ITopic } from "./topic-base";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { PolicyDocument, PolicyStatement } from "../iam";
+/**
+ * Properties to associate SNS topics with a policy
+ */
+export interface TopicPolicyProps extends AwsConstructProps {
+    /**
+     * The set of topics this policy applies to.
+     */
+    readonly topics: ITopic[];
+    /**
+     * IAM policy document to apply to topic(s).
+     * @default empty policy document
+     */
+    readonly policyDocument?: PolicyDocument;
+    /**
+     * Adds a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     *
+     * @default false
+     */
+    readonly enforceSSL?: boolean;
+}
+/**
+ * The policy for an SNS Topic
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * 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_sns_topic_policy
+ */
+export declare class TopicPolicy extends AwsConstructBase {
+    /**
+     * The IAM policy document associated with this policy.
+     */
+    readonly document: PolicyDocument;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: TopicPolicyProps);
+    /**
+     * Creates a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     */
+    protected createSSLPolicyStatement(topicArns: string[]): PolicyStatement;
+}

package/lib/aws/notify/policy.js

@@ -0,0 +1,83 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopicPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/6b9e47a1529319561bc1040739fe02bac15895bf/packages/aws-cdk-lib/aws-sns/lib/policy.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const iam_1 = require("../iam");
+/**
+ * The policy for an SNS Topic
+ *
+ * Policies define the operations that are allowed on this resource.
+ *
+ * You almost never need to define this construct directly.
+ *
+ * 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_sns_topic_policy
+ */
+class TopicPolicy extends aws_construct_1.AwsConstructBase {
+    // Outputs are minimal as this construct manages multiple policies
+    get outputs() {
+        return {
+            policyJson: this.document.json,
+        };
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.document =
+            props.policyDocument ??
+                new iam_1.PolicyDocument(this, "PolicyDocument", {
+                    // statements must be unique, so we use the statement index.
+                    // potentially SIDs can change as a result of order change, but this should
+                    // not have an impact on the policy evaluation.
+                    // https://docs.aws.amazon.com/sns/latest/dg/AccessPolicyLanguage_SpecialInfo.html
+                    assignSids: true,
+                });
+        if (props.enforceSSL) {
+            // preserving CFN behavior by using a single policy doc for all topics
+            this.document.addStatements(this.createSSLPolicyStatement(props.topics.map((topic) => topic.topicArn)));
+        }
+        // TF Provider AWS effectively sets the Policy attribute on every topic ...
+        // https://github.com/hashicorp/terraform-provider-aws/blob/v5.97.0/internal/service/sns/topic_policy.go#L73
+        props.topics.forEach((topic, index) => {
+            new provider_aws_1.snsTopicPolicy.SnsTopicPolicy(this, `Resource-${index}`, {
+                arn: topic.topicArn,
+                policy: this.document.json,
+            });
+        });
+    }
+    /**
+     * Creates a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * For more information, see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.
+     */
+    createSSLPolicyStatement(topicArns) {
+        return new iam_1.PolicyStatement({
+            // NOTE: SID needs to be unique within the policy for each topic
+            sid: "AllowPublishThroughSSLOnly",
+            actions: ["sns:Publish"],
+            effect: iam_1.Effect.DENY,
+            resources: topicArns,
+            condition: [
+                {
+                    test: "Bool",
+                    variable: "aws:SecureTransport",
+                    values: ["false"],
+                },
+            ],
+            principals: [new iam_1.StarPrincipal()],
+        });
+    }
+}
+exports.TopicPolicy = TopicPolicy;
+_a = JSII_RTTI_SYMBOL_1;
+TopicPolicy[_a] = { fqn: "terraconstructs.aws.notify.TopicPolicy", version: "0.0.18" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/queue-policy.js

@@ -35,5 +35,5 @@ class QueuePolicy extends aws_construct_1.AwsConstructBase {
 }
 exports.QueuePolicy = QueuePolicy;
 _a = JSII_RTTI_SYMBOL_1;
-QueuePolicy[_a] = { fqn: "terraconstructs.aws.notify.QueuePolicy", version: "0.0.17" };
+QueuePolicy[_a] = { fqn: "terraconstructs.aws.notify.QueuePolicy", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/queue.js

@@ -255,7 +255,7 @@ class Queue extends aws_construct_1.AwsConstructBase {
 }
 exports.Queue = Queue;
 _a = JSII_RTTI_SYMBOL_1;
-Queue[_a] = { fqn: "terraconstructs.aws.notify.Queue", version: "0.0.17" };
+Queue[_a] = { fqn: "terraconstructs.aws.notify.Queue", version: "0.0.18" };
 /**
  * The permission type that defines which source queues can specify the current queue as the dead-letter queue
  */

package/lib/aws/notify/resource-policy.js

@@ -39,5 +39,5 @@ class ResourcePolicy extends aws_construct_1.AwsConstructBase {
 }
 exports.ResourcePolicy = ResourcePolicy;
 _a = JSII_RTTI_SYMBOL_1;
-ResourcePolicy[_a] = { fqn: "terraconstructs.aws.notify.ResourcePolicy", version: "0.0.17" };
+ResourcePolicy[_a] = { fqn: "terraconstructs.aws.notify.ResourcePolicy", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/aws/notify/rule.js

@@ -224,5 +224,5 @@ class Rule extends aws_construct_1.AwsConstructBase {
 }
 exports.Rule = Rule;
 _a = JSII_RTTI_SYMBOL_1;
-Rule[_a] = { fqn: "terraconstructs.aws.notify.Rule", version: "0.0.17" };
+Rule[_a] = { fqn: "terraconstructs.aws.notify.Rule", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/aws/notify/rule.ts"],"names":[],"mappings":";;;;;AAAA,2FAA2F;AAE3F,sDAI6B;AAC7B,iCAAoC;AAEpC,gCAAmC;AACnC,oDAI0B;AAC1B,4CAAwC;AAQxC,iCAA+D;AAoG/D,MAAa,IAAK,SAAQ,gCAAgB;IACxC;;;;;;OAMG;IACI,MAAM,CAAC,gBAAgB,CAC5B,KAAgB,EAChB,EAAU,EACV,YAAoB;QAEpB,MAAM,KAAK,GAAG,oBAAQ,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,QAAQ,CACnD,YAAY,EACZ,eAAS,CAAC,mBAAmB,CAC9B,CAAC;QAEF,MAAM,MAAO,SAAQ,gCAAgB;YAArC;;gBACS,YAAO,GAAG,YAAY,CAAC;gBACvB,aAAQ,GAAG,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC;gBACpC,gBAAW,GAAG;oBACnB,IAAI,EAAE,IAAI,CAAC,QAAQ;oBACnB,GAAG,EAAE,IAAI,CAAC,OAAO;iBAClB,CAAC;gBACK,YAAO,GAAG,IAAI,CAAC,WAAW,CAAC;YACpC,CAAC;SAAA;QACD,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,EAAE;YAC3B,kBAAkB,EAAE,YAAY;SACjC,CAAC,CAAC;IACL,CAAC;IAGD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;IAC3B,CAAC;IACD,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC5B,CAAC;IACD,IAAW,WAAW;QACpB,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,QAAQ;YACnB,GAAG,EAAE,IAAI,CAAC,OAAO;SAClB,CAAC;IACJ,CAAC;IACD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAQD,YAAY,KAAgB,EAAE,IAAY,EAAE,QAAmB,EAAE;QAC/D,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;QAPX,YAAO,GACtB,IAAI,KAAK,EAAqD,CAAC;QAChD,iBAAY,GAAiB,EAAE,CAAC;QAO/C,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAC;QACJ,CAAC;QAED,IAAI,UAA8B,CAAC;QACnC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YACpB,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,wBAAwB,CAAC,IAAI,EAAE;gBACrD,MAAM,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ,GAAG,GAAG;gBAC/C,wBAAwB,EAAE,KAAK;gBAC/B,SAAS,EAAE,EAAE;aACd,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,QAAQ,EAAE,gBAAgB,CAAC;QAE3D,uEAAuE;QACvE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QAE5B,IAAI,CAAC,QAAQ,GAAG,IAAI,kCAAmB,CAAC,mBAAmB,CACzD,IAAI,EACJ,UAAU,EACV;YACE,IAAI,EAAE,KAAK,CAAC,QAAQ;YACpB,UAAU;YACV,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,KAAK,EACH,KAAK,CAAC,OAAO,IAAI,IAAI;gBACnB,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,KAAK,CAAC,OAAO;oBACb,CAAC,CAAC,SAAS;oBACX,CAAC,CAAC,UAAU,EAAE,8DAA8D;YAClF,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,YAAY,EAAE,YAAI,CAAC,WAAW,CAAC;gBAC7B,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;aACnE,CAAC;YACF,mEAAmE;YACnE,mEAAmE;YACnE,YAAY,EAAE,KAAK,CAAC,QAAQ,EAAE,YAAY;YAC1C,SAAS,EAAE,KAAK,CAAC,SAAS;SAC3B,CACF,CAAC;QAEF,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAEzC,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;YACzC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;YACtB,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,QAAQ,CAAC;SAClD,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACI,eAAe,CAAC,YAA2B;QAChD,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QACD,IAAA,wBAAiB,EAAC,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACI,mBAAmB;QACxB,OAAO,IAAA,yBAAkB,EAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC/C,CAAC;IAES,YAAY,CAAC,QAAiB;QACtC,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,aAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC5D,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;gBAChD,MAAM,IAAI,KAAK,CACb,kEAAkE,QAAQ,EAAE,CAC7E,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC1C,MAAM,IAAI,KAAK,CACb,mBAAmB,QAAQ,sFAAsF,CAClH,CAAC;YACJ,CAAC;QACH,CAAC;QAED,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,IACE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,KAAK,CAAC;YAC3C,CAAC,IAAI,CAAC,kBAAkB,EACxB,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,qDAAqD,CAAC,CAAC;QACrE,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;QAC7D,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,SAAS,CAAC,MAAoB;QACnC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO;QACT,CAAC;QACD,kFAAkF;QAClF,MAAM,QAAQ,GAAG,SAAS,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QAChD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAChD,MAAM,UAAU,GAAG,WAAW,CAAC,KAAK,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;YAChB,QAAQ;YACR,OAAO,EAAE,WAAW,CAAC,IAAI,EAAE,OAAO;YAClC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI;YACxB,GAAG,EAAE,WAAW,CAAC,GAAG;YACpB,SAAS,EAAE,WAAW,CAAC,aAAa;YACpC,UAAU,EAAE,WAAW,CAAC,cAAc;YACtC,aAAa,EAAE,WAAW,CAAC,iBAAiB;YAC5C,iBAAiB,EAAE,WAAW,CAAC,oBAAoB;YACnD,WAAW,EAAE,WAAW,CAAC,eAAe;YACxC,gBAAgB,EAAE,WAAW,CAAC,gBAAgB;YAC9C,WAAW,EAAE,WAAW,CAAC,WAAW;YACpC,SAAS,EAAE,WAAW,CAAC,aAAa;YACpC,cAAc,EAAE,WAAW,CAAC,sBAAsB;YAClD,gDAAgD;YAChD,oDAAoD;YACpD,KAAK,EAAE,UAAU,IAAI,UAAU,CAAC,KAAK;YACrC,SAAS,EAAE,UAAU,IAAI,UAAU,CAAC,SAAS;YAC7C,gBAAgB,EACd,UAAU,EAAE,aAAa,KAAK,SAAS;gBACrC,CAAC,CAAC;oBACE,aAAa,EAAE,UAAU,CAAC,aAAa;oBACvC,UAAU,EAAE,UAAU,CAAC,aAAa;iBACrC;gBACH,CAAC,CAAC,SAAS;SAChB,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,WAAW;QAChB;;WAEG;QACH,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAClC,8CAA8C;YAC9C,mGAAmG;YACnG,4GAA4G;YAC5G,IAAI,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,QAAS,CAAC;gBAAE,SAAS,CAAC,8BAA8B;YACtF,IAAI,oCAAqB,CAAC,qBAAqB,CAC7C,IAAI,EACJ,MAAM,CAAC,QAAS,EAChB,MAAM,CACP,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;;AA9PH,oBA+PC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.156.0/packages/aws-cdk-lib/aws-events/lib/rule.ts\n\nimport {\n  cloudwatchEventRule,\n  cloudwatchEventTarget,\n  //schedulerScheduleGroup //TODO: support scheduler groups?\n} from \"@cdktf/provider-aws\";\nimport { Lazy, Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat } from \"../arn\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport {\n  Schedule,\n  EventPattern,\n  IRuleTarget,\n  IEventBus,\n  EventCommonOptions,\n} from \"./\";\nimport { mergeEventPattern, renderEventPattern } from \"./util\";\n\nexport interface RuleProps extends AwsConstructProps, EventCommonOptions {\n  /**\n   * Indicates whether the rule is enabled.\n   *\n   * @default true\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Rule Name prefix to append to Grid UUID\n   *\n   * Rule names must be made up of only uppercase and lowercase ASCII letters,\n   * numbers, underscores, and hyphens, and Due to the length of the tf generated\n   * suffix, must be 64 characters or less long.\n   *\n   *\n   * @default - GridUUID + Stack Unique Name\n   */\n  readonly namePrefix?: string;\n\n  /**\n   * The schedule or rate (frequency) that determines when EventBridge\n   * runs the rule.\n   *\n   * You must specify this property, the `eventPattern` property, or both.\n   *\n   * For more information, see Schedule Expression Syntax for\n   * Rules in the Amazon EventBridge User Guide.\n   *\n   * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html\n   *\n   * @default - None.\n   */\n  readonly schedule?: Schedule;\n\n  /**\n   * Targets to invoke when this rule matches an event.\n   *\n   * Input will be the full matched event. If you wish to specify custom\n   * target input, use `addTarget(target[, inputOptions])`.\n   *\n   * @default - No targets.\n   */\n  readonly targets?: IRuleTarget[];\n\n  /**\n   * The event bus to associate with this rule.\n   *\n   * @default - The default event bus.\n   */\n  readonly eventBus?: IEventBus;\n\n  // /**\n  //  * Additional restrictions for the event to route to the specified target\n  //  *\n  //  * The method that generates the rule probably imposes some type of event\n  //  * filtering. The filtering implied by what you pass here is added\n  //  * on top of that filtering.\n  //  *\n  //  * @default - No additional filtering based on an event pattern.\n  //  *\n  //  * @see\n  //  * https://docs.aws.amazon.com/eventbridge/latest/userguide/eventbridge-and-event-patterns.html\n  //  */\n  // readonly eventPattern?: EventPattern;\n}\n\nexport interface RuleOutputs {\n  /**\n   * Rule name\n   */\n  readonly name: string;\n\n  /**\n   * Rule arn\n   */\n  readonly arn: string;\n}\n\nexport interface IRule extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly ruleOutputs: RuleOutputs;\n  /**\n   * The value of the event rule Amazon Resource Name (ARN), such as\n   * arn:aws:events:us-east-2:123456789012:rule/example.\n   *\n   * @attribute\n   */\n  readonly ruleArn: string;\n\n  /**\n   * The name event rule\n   *\n   * @attribute\n   */\n  readonly ruleName: string;\n}\n\nexport class Rule extends AwsConstructBase implements IRule {\n  /**\n   * Import an existing EventBridge Rule provided an ARN\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param eventRuleArn Event Rule ARN (i.e. arn:aws:events:<region>:<account-id>:rule/MyScheduledRule).\n   */\n  public static fromEventRuleArn(\n    scope: Construct,\n    id: string,\n    eventRuleArn: string,\n  ): IRule {\n    const parts = AwsStack.ofAwsConstruct(scope).splitArn(\n      eventRuleArn,\n      ArnFormat.SLASH_RESOURCE_NAME,\n    );\n\n    class Import extends AwsConstructBase implements IRule {\n      public ruleArn = eventRuleArn;\n      public ruleName = parts.resourceName || \"\";\n      public ruleOutputs = {\n        name: this.ruleName,\n        arn: this.ruleArn,\n      };\n      public outputs = this.ruleOutputs;\n    }\n    return new Import(scope, id, {\n      environmentFromArn: eventRuleArn,\n    });\n  }\n\n  public readonly resource: cloudwatchEventRule.CloudwatchEventRule;\n  public get ruleArn() {\n    return this.resource.arn;\n  }\n  public get ruleName() {\n    return this.resource.name;\n  }\n  public get ruleOutputs(): RuleOutputs {\n    return {\n      name: this.ruleName,\n      arn: this.ruleArn,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.ruleOutputs;\n  }\n\n  private readonly targets =\n    new Array<cloudwatchEventTarget.CloudwatchEventTargetConfig>();\n  private readonly eventPattern: EventPattern = {};\n\n  private readonly scheduleExpression?: string;\n  private readonly description?: string;\n  constructor(scope: Construct, name: string, props: RuleProps = {}) {\n    super(scope, name, props);\n\n    if (props.eventBus && props.schedule) {\n      throw new Error(\n        \"Cannot associate rule with 'eventBus' when using 'schedule'\",\n      );\n    }\n\n    let namePrefix: string | undefined;\n    if (!props.ruleName) {\n      namePrefix = this.stack.uniqueResourceNamePrefix(this, {\n        prefix: props.namePrefix ?? this.gridUUID + \"-\",\n        allowedSpecialCharacters: \".-_\",\n        maxLength: 64,\n      });\n    }\n    this.description = props.description;\n    this.scheduleExpression = props.schedule?.expressionString;\n\n    // add a warning on synth when minute is not defined in a cron schedule\n    props.schedule?._bind(this);\n\n    this.resource = new cloudwatchEventRule.CloudwatchEventRule(\n      this,\n      \"Resource\",\n      {\n        name: props.ruleName,\n        namePrefix,\n        description: this.description,\n        state:\n          props.enabled == null\n            ? \"ENABLED\"\n            : props.enabled\n              ? \"ENABLED\"\n              : \"DISABLED\", //TODO: support ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS?\n        scheduleExpression: this.scheduleExpression,\n        eventPattern: Lazy.stringValue({\n          produce: () => this.stack.toJsonString(this._renderEventPattern()),\n        }),\n        // terraform-provider-aws separates targets to different resources.\n        // targets: Lazy.anyValue({ produce: () => this.renderTargets() }),\n        eventBusName: props.eventBus?.eventBusName,\n        dependsOn: props.dependsOn,\n      },\n    );\n\n    this.addEventPattern(props.eventPattern);\n\n    for (const target of props.targets || []) {\n      this.addTarget(target);\n    }\n\n    this.node.addValidation({\n      validate: () => this.validateRule(props.ruleName),\n    });\n  }\n\n  /**\n   * Adds an event pattern filter to this rule. If a pattern was already specified,\n   * these values are merged into the existing pattern.\n   *\n   * For example, if the rule already contains the pattern:\n   *\n   *    {\n   *      \"resources\": [ \"r1\" ],\n   *      \"detail\": {\n   *        \"hello\": [ 1 ]\n   *      }\n   *    }\n   *\n   * And `addEventPattern` is called with the pattern:\n   *\n   *    {\n   *      \"resources\": [ \"r2\" ],\n   *      \"detail\": {\n   *        \"foo\": [ \"bar\" ]\n   *      }\n   *    }\n   *\n   * The resulting event pattern will be:\n   *\n   *    {\n   *      \"resources\": [ \"r1\", \"r2\" ],\n   *      \"detail\": {\n   *        \"hello\": [ 1 ],\n   *        \"foo\": [ \"bar\" ]\n   *      }\n   *    }\n   *\n   */\n  public addEventPattern(eventPattern?: EventPattern) {\n    if (!eventPattern) {\n      return;\n    }\n    mergeEventPattern(this.eventPattern, eventPattern);\n  }\n\n  /**\n   * Not private only to be overrideen in CopyRule.\n   *\n   * @internal\n   */\n  public _renderEventPattern(): any {\n    return renderEventPattern(this.eventPattern);\n  }\n\n  protected validateRule(ruleName?: string) {\n    if (ruleName !== undefined && !Token.isUnresolved(ruleName)) {\n      if (ruleName.length < 1 || ruleName.length > 64) {\n        throw new Error(\n          `Event rule name must be between 1 and 64 characters. Received: ${ruleName}`,\n        );\n      }\n      if (!/^[\\.\\-_A-Za-z0-9]+$/.test(ruleName)) {\n        throw new Error(\n          `Event rule name ${ruleName} can contain only letters, numbers, periods, hyphens, or underscores with no spaces.`,\n        );\n      }\n    }\n\n    const errors: string[] = [];\n    if (\n      Object.keys(this.eventPattern).length === 0 &&\n      !this.scheduleExpression\n    ) {\n      errors.push(\"Either 'eventPattern' or 'schedule' must be defined\");\n    }\n\n    if (this.targets.length > 5) {\n      errors.push(\"Event rule cannot have more than 5 targets.\");\n    }\n\n    return errors;\n  }\n\n  /**\n   * Adds a target to the rule. The abstract class RuleTarget can be extended to define new\n   * targets.\n   *\n   * No-op if target is undefined.\n   */\n  public addTarget(target?: IRuleTarget): void {\n    if (!target) {\n      return;\n    }\n    // Simply increment id for each `addTarget` call. This is guaranteed to be unique.\n    const targetId = `Target${this.targets.length}`;\n    const targetProps = target.bind(this, targetId);\n    const inputProps = targetProps.input && targetProps.input.bind(this);\n    this.targets.push({\n      targetId,\n      roleArn: targetProps.role?.roleArn,\n      rule: this.resource.name,\n      arn: targetProps.arn,\n      ecsTarget: targetProps.ecsParameters,\n      httpTarget: targetProps.httpParameters,\n      kinesisTarget: targetProps.kinesisParameters,\n      runCommandTargets: targetProps.runCommandParameters,\n      batchTarget: targetProps.batchParameters,\n      deadLetterConfig: targetProps.deadLetterConfig,\n      retryPolicy: targetProps.retryPolicy,\n      sqsTarget: targetProps.sqsParameters,\n      redshiftTarget: targetProps.redshiftDataParameters,\n      // TODO: not available in terraform-provider-aws\n      // appSyncParameters: targetProps.appSyncParameters,\n      input: inputProps && inputProps.input,\n      inputPath: inputProps && inputProps.inputPath,\n      inputTransformer:\n        inputProps?.inputTemplate !== undefined\n          ? {\n              inputTemplate: inputProps.inputTemplate,\n              inputPaths: inputProps.inputPathsMap,\n            }\n          : undefined,\n    });\n  }\n\n  /**\n   * Adds resource to the Terraform JSON output at Synth time.\n   *\n   * called by TerraformStack.prepareStack()\n   */\n  public toTerraform(): any {\n    /**\n     * A preparing resolve might add new resources to the stack\n     */\n    for (const target of this.targets) {\n      // note: targetId is calculated in addTarget()\n      // TODO: Ideally we should have used IResolvable.resolve and use the IResolveContext.preparing flag\n      // ref: https://github.com/aws/aws-cdk/blob/v2.170.0/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts#L48\n      if (this.node.tryFindChild(target.targetId!)) continue; // ignore if already generated\n      new cloudwatchEventTarget.CloudwatchEventTarget(\n        this,\n        target.targetId!,\n        target,\n      );\n    }\n    return {};\n  }\n}\n"]}

package/lib/aws/notify/schedule.js

@@ -85,7 +85,7 @@ class Schedule {
 }
 exports.Schedule = Schedule;
 _a = JSII_RTTI_SYMBOL_1;
-Schedule[_a] = { fqn: "terraconstructs.aws.notify.Schedule", version: "0.0.17" };
+Schedule[_a] = { fqn: "terraconstructs.aws.notify.Schedule", version: "0.0.18" };
 class LiteralSchedule extends Schedule {
     constructor(expressionString) {
         super();