terraconstructs 0.0.17 → 0.0.18

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

@@ -0,0 +1,222 @@
+import { Construct } from "constructs";
+import { AwsConstructProps } from "../aws-construct";
+import * as encryption from "../encryption";
+import * as iam from "../iam";
+import { ITopic, TopicBase } from "./topic-base";
+/**
+ * Properties for a new SNS topic
+ */
+export interface TopicProps extends AwsConstructProps {
+    /**
+     * A developer-defined string that can be used to identify this SNS topic.
+     *
+     * The display name must be maximum 100 characters long, including hyphens (-),
+     * underscores (_), spaces, and tabs.
+     *
+     * @default None
+     */
+    readonly displayName?: string;
+    /**
+     * A name for the topic.
+     *
+     * If you don't specify a name, AWS CloudFormation generates a unique
+     * physical ID and uses that ID for the topic name. For more information,
+     * see Name Type.
+     *
+     * @default Generated name
+     */
+    readonly topicName?: string;
+    /**
+     * A KMS Key, either managed by this CDK app, or imported.
+     *
+     * @default None
+     */
+    readonly masterKey?: encryption.IKey;
+    /**
+     * Enables content-based deduplication for FIFO topics.
+     *
+     * @default None
+     */
+    readonly contentBasedDeduplication?: boolean;
+    /**
+     * Set to true to create a FIFO topic.
+     *
+     * @default None
+     */
+    readonly fifo?: boolean;
+    /**
+     * The list of delivery status logging configurations for the topic.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/sns-topic-attributes.html.
+     *
+     * @default None
+     */
+    readonly loggingConfigs?: LoggingConfig[];
+    /**
+     * The number of days Amazon SNS retains messages.
+     *
+     * It can only be set for FIFO topics.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/fifo-message-archiving-replay.html
+     *
+     * @default - do not archive messages
+     */
+    readonly messageRetentionPeriodInDays?: number;
+    /**
+     * Adds a statement to enforce encryption of data in transit when publishing to the topic.
+     *
+     * @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 signature version corresponds to the hashing algorithm used while creating the signature of the notifications,
+     * subscription confirmations, or unsubscribe confirmation messages sent by Amazon SNS.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/sns-verify-signature-of-message.html.
+     *
+     * @default 1
+     */
+    readonly signatureVersion?: string;
+    /**
+     * Tracing mode of an Amazon SNS topic.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/sns-active-tracing.html
+     *
+     * @default TracingConfig.PASS_THROUGH
+     */
+    readonly tracingConfig?: TracingConfig;
+}
+/**
+ * A logging configuration for delivery status of messages sent from SNS topic to subscribed endpoints.
+ *
+ * @see https://docs.aws.amazon.com/sns/latest/dg/sns-topic-attributes.html.
+ */
+export interface LoggingConfig {
+    /**
+     * Indicates one of the supported protocols for the SNS topic.
+     */
+    readonly protocol: LoggingProtocol;
+    /**
+     * The IAM role to be used when logging failed message deliveries in Amazon CloudWatch.
+     *
+     * @default None
+     */
+    readonly failureFeedbackRole?: iam.IRole;
+    /**
+     * The IAM role to be used when logging successful message deliveries in Amazon CloudWatch.
+     *
+     * @default None
+     */
+    readonly successFeedbackRole?: iam.IRole;
+    /**
+     * The percentage of successful message deliveries to be logged in Amazon CloudWatch.
+     *
+     * Valid values are integer between 0-100
+     *
+     * @default None
+     */
+    readonly successFeedbackSampleRate?: number;
+}
+/**
+ * The type of supported protocol for delivery status logging.
+ */
+export declare enum LoggingProtocol {
+    /**
+     * HTTP
+     */
+    HTTP = "http",// NOTE: AWSCDK enum value = "http/s",
+    /**
+     * Amazon Simple Queue Service
+     */
+    SQS = "sqs",
+    /**
+     * AWS Lambda
+     */
+    LAMBDA = "lambda",
+    /**
+     * Amazon Data Firehose
+     */
+    FIREHOSE = "firehose",
+    /**
+     * Platform application endpoint
+     */
+    APPLICATION = "application"
+}
+/**
+ * The tracing mode of an Amazon SNS topic
+ */
+export declare enum TracingConfig {
+    /**
+     * The mode that topic passes trace headers received from the Amazon SNS publisher to its subscription.
+     */
+    PASS_THROUGH = "PassThrough",
+    /**
+     * The mode that Amazon SNS vend X-Ray segment data to topic owner account if the sampled flag in the tracing header is true.
+     */
+    ACTIVE = "Active"
+}
+/**
+ * Represents an SNS topic defined outside of this stack.
+ */
+export interface TopicAttributes {
+    /**
+     * The ARN of the SNS topic.
+     */
+    readonly topicArn: string;
+    /**
+     * KMS encryption key ARN, if this topic is server-side encrypted by a KMS key.
+     *
+     * @default - None
+     */
+    readonly keyArn?: string;
+    /**
+     * Whether content-based deduplication is enabled.
+     * Only applicable for FIFO topics.
+     *
+     * @default false
+     */
+    readonly contentBasedDeduplication?: boolean;
+}
+/**
+ * A new SNS topic
+ *
+ * @resource aws_sns_topic
+ */
+export declare class Topic extends TopicBase {
+    /**
+     * Import an existing SNS topic provided an ARN
+     *
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param topicArn topic ARN (i.e. arn:aws:sns:us-east-2:444455556666:MyTopic)
+     */
+    static fromTopicArn(scope: Construct, id: string, topicArn: string): ITopic;
+    /**
+     * Import an existing SNS topic provided a topic attributes
+     *
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param attrs the attributes of the topic to import
+     */
+    static fromTopicAttributes(scope: Construct, id: string, attrs: TopicAttributes): ITopic;
+    readonly topicArn: string;
+    readonly topicName: string;
+    readonly masterKey?: encryption.IKey;
+    readonly contentBasedDeduplication: boolean;
+    readonly fifo: boolean;
+    protected readonly autoCreatePolicy: boolean;
+    private readonly resource;
+    constructor(scope: Construct, id: string, props?: TopicProps);
+    /**
+     * Adds a delivery status logging configuration to the topic.
+     */
+    addLoggingConfig(config: LoggingConfig): void;
+    /**
+     * Adds an IAM policy statement to enforce the use of TLS for publishing to this topic.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit
+     */
+    protected addSSLPolicy(): void;
+}

package/lib/aws/notify/topic.js

@@ -0,0 +1,219 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topic = exports.TracingConfig = exports.LoggingProtocol = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/a7633a98ce325a620f364bfdeda354342751900a/packages/aws-cdk-lib/aws-sns/lib/topic.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const __1 = require("..");
+const encryption = require("../encryption");
+const iam = require("../iam");
+const topic_base_1 = require("./topic-base");
+/**
+ * The type of supported protocol for delivery status logging.
+ */
+var LoggingProtocol;
+(function (LoggingProtocol) {
+    /**
+     * HTTP
+     */
+    LoggingProtocol["HTTP"] = "http";
+    /**
+     * Amazon Simple Queue Service
+     */
+    LoggingProtocol["SQS"] = "sqs";
+    /**
+     * AWS Lambda
+     */
+    LoggingProtocol["LAMBDA"] = "lambda";
+    /**
+     * Amazon Data Firehose
+     */
+    LoggingProtocol["FIREHOSE"] = "firehose";
+    /**
+     * Platform application endpoint
+     */
+    LoggingProtocol["APPLICATION"] = "application";
+})(LoggingProtocol || (exports.LoggingProtocol = LoggingProtocol = {}));
+/**
+ * The tracing mode of an Amazon SNS topic
+ */
+var TracingConfig;
+(function (TracingConfig) {
+    /**
+     * The mode that topic passes trace headers received from the Amazon SNS publisher to its subscription.
+     */
+    TracingConfig["PASS_THROUGH"] = "PassThrough";
+    /**
+     * The mode that Amazon SNS vend X-Ray segment data to topic owner account if the sampled flag in the tracing header is true.
+     */
+    TracingConfig["ACTIVE"] = "Active";
+})(TracingConfig || (exports.TracingConfig = TracingConfig = {}));
+/**
+ * A new SNS topic
+ *
+ * @resource aws_sns_topic
+ */
+class Topic extends topic_base_1.TopicBase {
+    /**
+     * Import an existing SNS topic provided an ARN
+     *
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param topicArn topic ARN (i.e. arn:aws:sns:us-east-2:444455556666:MyTopic)
+     */
+    static fromTopicArn(scope, id, topicArn) {
+        return Topic.fromTopicAttributes(scope, id, { topicArn });
+    }
+    /**
+     * Import an existing SNS topic provided a topic attributes
+     *
+     * @param scope The parent creating construct
+     * @param id The construct's name
+     * @param attrs the attributes of the topic to import
+     */
+    static fromTopicAttributes(scope, id, attrs) {
+        const stack = __1.AwsStack.ofAwsConstruct(scope);
+        const topicName = stack.splitArn(attrs.topicArn, __1.ArnFormat.NO_RESOURCE_NAME).resource;
+        const fifo = topicName.endsWith(".fifo");
+        if (attrs.contentBasedDeduplication && !fifo) {
+            throw new Error("Cannot import topic; contentBasedDeduplication is only available for FIFO SNS topics.");
+        }
+        class Import extends topic_base_1.TopicBase {
+            constructor() {
+                super(...arguments);
+                this.topicArn = attrs.topicArn;
+                this.topicName = topicName;
+                this.masterKey = attrs.keyArn
+                    ? encryption.Key.fromKeyArn(this, "Key", attrs.keyArn)
+                    : undefined;
+                this.fifo = fifo;
+                this.contentBasedDeduplication = attrs.contentBasedDeduplication || false;
+                this.autoCreatePolicy = false;
+            }
+        }
+        return new Import(scope, id, {
+            environmentFromArn: attrs.topicArn,
+        });
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.autoCreatePolicy = true;
+        this.enforceSSL = props.enforceSSL;
+        if (props.contentBasedDeduplication && !props.fifo) {
+            throw new Error("Content based deduplication can only be enabled for FIFO SNS topics.");
+        }
+        if (props.messageRetentionPeriodInDays && !props.fifo) {
+            throw new Error("`messageRetentionPeriodInDays` is only valid for FIFO SNS topics.");
+        }
+        // TODO: fifoThroughputScope validation removed as property is not supported
+        // if (props.fifoThroughputScope && !props.fifo) {
+        //   throw new Error('`fifoThroughputScope` can only be set for FIFO SNS topics.');
+        // }
+        if (props.messageRetentionPeriodInDays !== undefined &&
+            !cdktf_1.Token.isUnresolved(props.messageRetentionPeriodInDays) &&
+            (!Number.isInteger(props.messageRetentionPeriodInDays) ||
+                props.messageRetentionPeriodInDays > 365 ||
+                props.messageRetentionPeriodInDays < 1)) {
+            throw new Error("`messageRetentionPeriodInDays` must be an integer between 1 and 365");
+        }
+        let topicName = props.topicName;
+        if (props.fifo && props.topicName && !props.topicName.endsWith(".fifo")) {
+            topicName = props.topicName + ".fifo";
+        }
+        else if (props.fifo && !props.topicName) {
+            // Max length allowed by CloudFormation is 256, we subtract 5 to allow for ".fifo" suffix
+            const prefixName = this.stack.uniqueResourceName(this, {
+                maxLength: 256 - 5,
+                separator: "-",
+            });
+            topicName = `${prefixName}.fifo`;
+        }
+        if (props.signatureVersion &&
+            !cdktf_1.Token.isUnresolved(props.signatureVersion) &&
+            props.signatureVersion !== "1" &&
+            props.signatureVersion !== "2") {
+            throw new Error(`signatureVersion must be "1" or "2", received: "${props.signatureVersion}"`);
+        }
+        if (props.displayName &&
+            !cdktf_1.Token.isUnresolved(props.displayName) &&
+            props.displayName.length > 100) {
+            throw new Error(`displayName must be less than or equal to 100 characters, got ${props.displayName.length}`);
+        }
+        this.resource = new provider_aws_1.snsTopic.SnsTopic(this, "Resource", {
+            name: topicName,
+            displayName: props.displayName,
+            kmsMasterKeyId: props.masterKey?.keyArn,
+            contentBasedDeduplication: props.contentBasedDeduplication,
+            fifoTopic: props.fifo,
+            signatureVersion: props.signatureVersion
+                ? parseInt(props.signatureVersion, 10)
+                : undefined,
+            tracingConfig: props.tracingConfig,
+            archivePolicy: props.messageRetentionPeriodInDays
+                ? JSON.stringify({
+                    MessageRetentionPeriod: props.messageRetentionPeriodInDays,
+                })
+                : undefined,
+            // TODO: fifoThroughputScope is not supported in Terraform as of provider v5.93.0
+        });
+        // add logging config overrides
+        if (props.loggingConfigs) {
+            props.loggingConfigs.forEach((c) => this.addLoggingConfig(c));
+        }
+        this.topicArn = this.resource.arn;
+        this.topicName = this.resource.name;
+        this.masterKey = props.masterKey;
+        this.fifo = props.fifo || false;
+        this.contentBasedDeduplication = props.contentBasedDeduplication || false;
+        if (this.enforceSSL) {
+            this.addSSLPolicy();
+        }
+    }
+    /**
+     * Adds a delivery status logging configuration to the topic.
+     */
+    addLoggingConfig(config) {
+        if (config.successFeedbackSampleRate !== undefined) {
+            const rate = config.successFeedbackSampleRate;
+            if (!Number.isInteger(rate) || rate < 0 || rate > 100) {
+                throw new Error("Success feedback sample rate must be an integer between 0 and 100");
+            }
+        }
+        if (config.failureFeedbackRole) {
+            this.resource.addOverride(`${config.protocol}_failure_feedback_role_arn`, config.failureFeedbackRole.roleArn);
+        }
+        if (config.successFeedbackRole) {
+            this.resource.addOverride(`${config.protocol}_success_feedback_role_arn`, config.successFeedbackRole.roleArn);
+        }
+        if (config.successFeedbackSampleRate !== undefined) {
+            this.resource.addOverride(`${config.protocol}_success_feedback_sample_rate`, config.successFeedbackSampleRate.toString());
+        }
+    }
+    /**
+     * Adds an IAM policy statement to enforce the use of TLS for publishing to this topic.
+     *
+     * @see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit
+     */
+    addSSLPolicy() {
+        this.addToResourcePolicy(new iam.PolicyStatement({
+            sid: "EnforcePublishSSL",
+            actions: ["sns:Publish"],
+            effect: iam.Effect.DENY,
+            resources: [this.topicArn],
+            principals: [new iam.AnyPrincipal()],
+            condition: [
+                {
+                    test: "Bool",
+                    variable: "aws:SecureTransport",
+                    values: ["false"],
+                },
+            ],
+        }));
+    }
+}
+exports.Topic = Topic;
+_a = JSII_RTTI_SYMBOL_1;
+Topic[_a] = { fqn: "terraconstructs.aws.notify.Topic", version: "0.0.18" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"topic.js","sourceRoot":"","sources":["../../../src/aws/notify/topic.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/a7633a98ce325a620f364bfdeda354342751900a/packages/aws-cdk-lib/aws-sns/lib/topic.ts\n\nimport { snsTopic } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { ArnFormat, AwsStack } from \"..\";\nimport { AwsConstructProps } from \"../aws-construct\";\nimport * as encryption from \"../encryption\";\nimport * as iam from \"../iam\";\nimport { ITopic, TopicBase } from \"./topic-base\";\n\n/**\n * Properties for a new SNS topic\n */\nexport interface TopicProps extends AwsConstructProps {\n  /**\n   * A developer-defined string that can be used to identify this SNS topic.\n   *\n   * The display name must be maximum 100 characters long, including hyphens (-),\n   * underscores (_), spaces, and tabs.\n   *\n   * @default None\n   */\n  readonly displayName?: string;\n\n  /**\n   * A name for the topic.\n   *\n   * If you don't specify a name, AWS CloudFormation generates a unique\n   * physical ID and uses that ID for the topic name. For more information,\n   * see Name Type.\n   *\n   * @default Generated name\n   */\n  readonly topicName?: string;\n\n  /**\n   * A KMS Key, either managed by this CDK app, or imported.\n   *\n   * @default None\n   */\n  readonly masterKey?: encryption.IKey;\n\n  /**\n   * Enables content-based deduplication for FIFO topics.\n   *\n   * @default None\n   */\n  readonly contentBasedDeduplication?: boolean;\n\n  /**\n   * Set to true to create a FIFO topic.\n   *\n   * @default None\n   */\n  readonly fifo?: boolean;\n\n  /**\n   * The list of delivery status logging configurations for the topic.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/sns-topic-attributes.html.\n   *\n   * @default None\n   */\n  readonly loggingConfigs?: LoggingConfig[];\n\n  /**\n   * The number of days Amazon SNS retains messages.\n   *\n   * It can only be set for FIFO topics.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/fifo-message-archiving-replay.html\n   *\n   * @default - do not archive messages\n   */\n  readonly messageRetentionPeriodInDays?: number;\n\n  /**\n   * Adds a statement to enforce encryption of data in transit when publishing to the topic.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit.\n   *\n   * @default false\n   */\n  readonly enforceSSL?: boolean;\n\n  /**\n   * The signature version corresponds to the hashing algorithm used while creating the signature of the notifications,\n   * subscription confirmations, or unsubscribe confirmation messages sent by Amazon SNS.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/sns-verify-signature-of-message.html.\n   *\n   * @default 1\n   */\n  readonly signatureVersion?: string;\n\n  /**\n   * Tracing mode of an Amazon SNS topic.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/sns-active-tracing.html\n   *\n   * @default TracingConfig.PASS_THROUGH\n   */\n  readonly tracingConfig?: TracingConfig;\n\n  // TODO: fifoThroughputScope is not directly supported by aws_sns_topic in Terraform as of provider v5.93.0\n  // /**\n  //  * Specifies the throughput quota and deduplication behavior to apply for the FIFO topic.\n  //  *\n  //  * You can only set this property when `fifo` is `true`.\n  //  *\n  //  * @default undefined - SNS default setting is FifoThroughputScope.TOPIC\n  //  */\n  // readonly fifoThroughputScope?: FifoThroughputScope;\n}\n\n// TODO: fifoThroughputScope is not directly supported by aws_sns_topic in Terraform as of provider v5.93.0\n// /**\n//  * The throughput quota and deduplication behavior to apply for the FIFO topic.\n//  */\n// export enum FifoThroughputScope {\n//   /**\n//    * Topic scope\n//    * - Throughput: 3000 messages per second and a bandwidth of 20MB per second.\n//    * - Deduplication: Message deduplication is verified on the entire FIFO topic.\n//    */\n//   TOPIC = 'Topic',\n\n//   /**\n//    * Message group scope\n//    * - Throughput: Maximum regional limits.\n//    * - Deduplication: Message deduplication is only verified within a message group.\n//    */\n//   MESSAGE_GROUP = 'MessageGroup',\n// }\n\n/**\n * A logging configuration for delivery status of messages sent from SNS topic to subscribed endpoints.\n *\n * @see https://docs.aws.amazon.com/sns/latest/dg/sns-topic-attributes.html.\n */\nexport interface LoggingConfig {\n  /**\n   * Indicates one of the supported protocols for the SNS topic.\n   */\n  readonly protocol: LoggingProtocol;\n\n  /**\n   * The IAM role to be used when logging failed message deliveries in Amazon CloudWatch.\n   *\n   * @default None\n   */\n  readonly failureFeedbackRole?: iam.IRole;\n\n  /**\n   * The IAM role to be used when logging successful message deliveries in Amazon CloudWatch.\n   *\n   * @default None\n   */\n  readonly successFeedbackRole?: iam.IRole;\n\n  /**\n   * The percentage of successful message deliveries to be logged in Amazon CloudWatch.\n   *\n   * Valid values are integer between 0-100\n   *\n   * @default None\n   */\n  readonly successFeedbackSampleRate?: number;\n}\n\n/**\n * The type of supported protocol for delivery status logging.\n */\nexport enum LoggingProtocol {\n  /**\n   * HTTP\n   */\n  HTTP = \"http\", // NOTE: AWSCDK enum value = \"http/s\",\n\n  /**\n   * Amazon Simple Queue Service\n   */\n  SQS = \"sqs\",\n\n  /**\n   * AWS Lambda\n   */\n  LAMBDA = \"lambda\",\n\n  /**\n   * Amazon Data Firehose\n   */\n  FIREHOSE = \"firehose\",\n\n  /**\n   * Platform application endpoint\n   */\n  APPLICATION = \"application\",\n}\n\n/**\n * The tracing mode of an Amazon SNS topic\n */\nexport enum TracingConfig {\n  /**\n   * The mode that topic passes trace headers received from the Amazon SNS publisher to its subscription.\n   */\n  PASS_THROUGH = \"PassThrough\",\n\n  /**\n   * The mode that Amazon SNS vend X-Ray segment data to topic owner account if the sampled flag in the tracing header is true.\n   */\n  ACTIVE = \"Active\",\n}\n\n/**\n * Represents an SNS topic defined outside of this stack.\n */\nexport interface TopicAttributes {\n  /**\n   * The ARN of the SNS topic.\n   */\n  readonly topicArn: string;\n\n  /**\n   * KMS encryption key ARN, if this topic is server-side encrypted by a KMS key.\n   *\n   * @default - None\n   */\n  readonly keyArn?: string;\n\n  /**\n   * Whether content-based deduplication is enabled.\n   * Only applicable for FIFO topics.\n   *\n   * @default false\n   */\n  readonly contentBasedDeduplication?: boolean;\n}\n\n/**\n * A new SNS topic\n *\n * @resource aws_sns_topic\n */\nexport class Topic extends TopicBase {\n  /**\n   * Import an existing SNS topic provided an ARN\n   *\n   * @param scope The parent creating construct\n   * @param id The construct's name\n   * @param topicArn topic ARN (i.e. arn:aws:sns:us-east-2:444455556666:MyTopic)\n   */\n  public static fromTopicArn(\n    scope: Construct,\n    id: string,\n    topicArn: string,\n  ): ITopic {\n    return Topic.fromTopicAttributes(scope, id, { topicArn });\n  }\n\n  /**\n   * Import an existing SNS topic provided a topic attributes\n   *\n   * @param scope The parent creating construct\n   * @param id The construct's name\n   * @param attrs the attributes of the topic to import\n   */\n  public static fromTopicAttributes(\n    scope: Construct,\n    id: string,\n    attrs: TopicAttributes,\n  ): ITopic {\n    const stack = AwsStack.ofAwsConstruct(scope);\n    const topicName = stack.splitArn(\n      attrs.topicArn,\n      ArnFormat.NO_RESOURCE_NAME,\n    ).resource;\n    const fifo = topicName.endsWith(\".fifo\");\n\n    if (attrs.contentBasedDeduplication && !fifo) {\n      throw new Error(\n        \"Cannot import topic; contentBasedDeduplication is only available for FIFO SNS topics.\",\n      );\n    }\n\n    class Import extends TopicBase {\n      public readonly topicArn = attrs.topicArn;\n      public readonly topicName = topicName;\n      public readonly masterKey = attrs.keyArn\n        ? encryption.Key.fromKeyArn(this, \"Key\", attrs.keyArn)\n        : undefined;\n      public readonly fifo = fifo;\n      public readonly contentBasedDeduplication =\n        attrs.contentBasedDeduplication || false;\n      protected autoCreatePolicy: boolean = false;\n    }\n\n    return new Import(scope, id, {\n      environmentFromArn: attrs.topicArn,\n    });\n  }\n\n  public readonly topicArn: string;\n  public readonly topicName: string;\n  public readonly masterKey?: encryption.IKey;\n  public readonly contentBasedDeduplication: boolean;\n  public readonly fifo: boolean;\n\n  protected readonly autoCreatePolicy: boolean = true;\n\n  private readonly resource: snsTopic.SnsTopic;\n\n  constructor(scope: Construct, id: string, props: TopicProps = {}) {\n    super(scope, id, props);\n\n    this.enforceSSL = props.enforceSSL;\n\n    if (props.contentBasedDeduplication && !props.fifo) {\n      throw new Error(\n        \"Content based deduplication can only be enabled for FIFO SNS topics.\",\n      );\n    }\n    if (props.messageRetentionPeriodInDays && !props.fifo) {\n      throw new Error(\n        \"`messageRetentionPeriodInDays` is only valid for FIFO SNS topics.\",\n      );\n    }\n    // TODO: fifoThroughputScope validation removed as property is not supported\n    // if (props.fifoThroughputScope && !props.fifo) {\n    //   throw new Error('`fifoThroughputScope` can only be set for FIFO SNS topics.');\n    // }\n    if (\n      props.messageRetentionPeriodInDays !== undefined &&\n      !Token.isUnresolved(props.messageRetentionPeriodInDays) &&\n      (!Number.isInteger(props.messageRetentionPeriodInDays) ||\n        props.messageRetentionPeriodInDays > 365 ||\n        props.messageRetentionPeriodInDays < 1)\n    ) {\n      throw new Error(\n        \"`messageRetentionPeriodInDays` must be an integer between 1 and 365\",\n      );\n    }\n\n    let topicName = props.topicName;\n    if (props.fifo && props.topicName && !props.topicName.endsWith(\".fifo\")) {\n      topicName = props.topicName + \".fifo\";\n    } else if (props.fifo && !props.topicName) {\n      // Max length allowed by CloudFormation is 256, we subtract 5 to allow for \".fifo\" suffix\n      const prefixName = this.stack.uniqueResourceName(this, {\n        maxLength: 256 - 5,\n        separator: \"-\",\n      });\n      topicName = `${prefixName}.fifo`;\n    }\n\n    if (\n      props.signatureVersion &&\n      !Token.isUnresolved(props.signatureVersion) &&\n      props.signatureVersion !== \"1\" &&\n      props.signatureVersion !== \"2\"\n    ) {\n      throw new Error(\n        `signatureVersion must be \"1\" or \"2\", received: \"${props.signatureVersion}\"`,\n      );\n    }\n\n    if (\n      props.displayName &&\n      !Token.isUnresolved(props.displayName) &&\n      props.displayName.length > 100\n    ) {\n      throw new Error(\n        `displayName must be less than or equal to 100 characters, got ${props.displayName.length}`,\n      );\n    }\n\n    this.resource = new snsTopic.SnsTopic(this, \"Resource\", {\n      name: topicName,\n      displayName: props.displayName,\n      kmsMasterKeyId: props.masterKey?.keyArn,\n      contentBasedDeduplication: props.contentBasedDeduplication,\n      fifoTopic: props.fifo,\n      signatureVersion: props.signatureVersion\n        ? parseInt(props.signatureVersion, 10)\n        : undefined,\n      tracingConfig: props.tracingConfig,\n      archivePolicy: props.messageRetentionPeriodInDays\n        ? JSON.stringify({\n            MessageRetentionPeriod: props.messageRetentionPeriodInDays,\n          })\n        : undefined,\n      // TODO: fifoThroughputScope is not supported in Terraform as of provider v5.93.0\n    });\n\n    // add logging config overrides\n    if (props.loggingConfigs) {\n      props.loggingConfigs.forEach((c) => this.addLoggingConfig(c));\n    }\n\n    this.topicArn = this.resource.arn;\n    this.topicName = this.resource.name;\n    this.masterKey = props.masterKey;\n    this.fifo = props.fifo || false;\n    this.contentBasedDeduplication = props.contentBasedDeduplication || false;\n\n    if (this.enforceSSL) {\n      this.addSSLPolicy();\n    }\n  }\n\n  /**\n   * Adds a delivery status logging configuration to the topic.\n   */\n  public addLoggingConfig(config: LoggingConfig) {\n    if (config.successFeedbackSampleRate !== undefined) {\n      const rate = config.successFeedbackSampleRate;\n      if (!Number.isInteger(rate) || rate < 0 || rate > 100) {\n        throw new Error(\n          \"Success feedback sample rate must be an integer between 0 and 100\",\n        );\n      }\n    }\n\n    if (config.failureFeedbackRole) {\n      this.resource.addOverride(\n        `${config.protocol}_failure_feedback_role_arn`,\n        config.failureFeedbackRole.roleArn,\n      );\n    }\n\n    if (config.successFeedbackRole) {\n      this.resource.addOverride(\n        `${config.protocol}_success_feedback_role_arn`,\n        config.successFeedbackRole.roleArn,\n      );\n    }\n\n    if (config.successFeedbackSampleRate !== undefined) {\n      this.resource.addOverride(\n        `${config.protocol}_success_feedback_sample_rate`,\n        config.successFeedbackSampleRate.toString(),\n      );\n    }\n  }\n\n  /**\n   * Adds an IAM policy statement to enforce the use of TLS for publishing to this topic.\n   *\n   * @see https://docs.aws.amazon.com/sns/latest/dg/sns-security-best-practices.html#enforce-encryption-data-in-transit\n   */\n  protected addSSLPolicy(): void {\n    this.addToResourcePolicy(\n      new iam.PolicyStatement({\n        sid: \"EnforcePublishSSL\",\n        actions: [\"sns:Publish\"],\n        effect: iam.Effect.DENY,\n        resources: [this.topicArn],\n        principals: [new iam.AnyPrincipal()],\n        condition: [\n          {\n            test: \"Bool\",\n            variable: \"aws:SecureTransport\",\n            values: [\"false\"],\n          },\n        ],\n      }),\n    );\n  }\n}\n"]}

package/lib/aws/storage/bucket-notifications.js

@@ -165,5 +165,5 @@ class BucketNotifications extends aws_construct_1.AwsConstructBase {
 }
 exports.BucketNotifications = BucketNotifications;
 _a = JSII_RTTI_SYMBOL_1;
-BucketNotifications[_a] = { fqn: "terraconstructs.aws.storage.BucketNotifications", version: "0.0.17" };
+BucketNotifications[_a] = { fqn: "terraconstructs.aws.storage.BucketNotifications", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bucket-notifications.js","sourceRoot":"","sources":["../../../src/aws/storage/bucket-notifications.ts"],"names":[],"mappings":"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","sourcesContent":["import { s3BucketNotification } from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { IBucket, EventType, NotificationKeyFilter } from \"./bucket\";\nimport {\n  BucketNotificationDestinationType,\n  IBucketNotificationDestination,\n} from \"./bucket-destination\";\n\nexport interface NotificationsProps extends AwsConstructProps {\n  /**\n   * The bucket to manage notifications for.\n   */\n  readonly bucket: IBucket;\n}\n\n/**\n * A custom CloudFormation resource that updates bucket notifications for a\n * bucket. The reason we need it is because the AWS::S3::Bucket notification\n * configuration is defined on the bucket itself, which makes it impossible to\n * provision notifications at the same time as the target (since\n * PutBucketNotifications validates the targets).\n *\n * Since only a single BucketNotifications resource is allowed for each Bucket,\n * this construct is not exported in the public API of this module. Instead, it\n * is created just-in-time by `s3.Bucket.onEvent`, so a 1:1 relationship is\n * ensured.\n *\n * @see\n * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-notificationconfig.html\n */\nexport class BucketNotifications extends AwsConstructBase {\n  public resource?: s3BucketNotification.S3BucketNotification;\n  public get outputs(): Record<string, any> {\n    return {};\n  }\n\n  private eventBridgeEnabled = false;\n  private readonly lambdaNotifications =\n    new Array<s3BucketNotification.S3BucketNotificationLambdaFunction>();\n  private readonly queueNotifications =\n    new Array<s3BucketNotification.S3BucketNotificationQueue>();\n  private readonly topicNotifications =\n    new Array<s3BucketNotification.S3BucketNotificationTopic>();\n  private readonly bucket: IBucket;\n\n  constructor(scope: Construct, id: string, props: NotificationsProps) {\n    super(scope, id);\n    this.bucket = props.bucket;\n  }\n\n  /**\n   * Adds a notification subscription for this bucket.\n   * If this is the first notification, a BucketNotification resource is added to the stack.\n   *\n   * @param event The type of event\n   * @param target The target construct\n   * @param filters A set of S3 key filters\n   */\n  public addNotification(\n    event: EventType,\n    target: IBucketNotificationDestination,\n    ...filters: NotificationKeyFilter[]\n  ) {\n    const resource = this.createResourceOnce();\n    // TODO: Seems Terraform provider does not have limitations on prefix and suffix?\n    // let hasPrefix = false;\n    // let hasSuffix = false;\n    for (const filter of filters) {\n      // if (!filter.suffix && !filter.prefix) {\n      //   throw new Error(\n      //     \"NotificationKeyFilter must specify `prefix` and/or `suffix`\",\n      //   );\n      // }\n      // if (filter.suffix) {\n      //   if (hasSuffix) {\n      //     throw new Error(\n      //       \"Cannot specify more than one suffix rule in a filter.\",\n      //     );\n      //   }\n      //   hasSuffix = true;\n      // }\n      // if (filter.prefix) {\n      //   if (hasPrefix) {\n      //     throw new Error(\n      //       \"Cannot specify more than one prefix rule in a filter.\",\n      //     );\n      //   }\n      //   hasPrefix = true;\n      // }\n      // resolve target. this also provides an opportunity for the target to e.g. update\n      // policies to allow this notification to happen.\n      const targetProps = target.bind(this, this.bucket);\n      const commonConfig: CommonConfiguration = {\n        events: [event],\n        id: filter.id,\n        filterPrefix: filter.prefix,\n        filterSuffix: filter.suffix,\n      };\n\n      // if the target specifies any dependencies, add them here.\n      // for example, the SNS topic policy must be created /before/ the notification resource.\n      // otherwise, S3 won't be able to confirm the subscription.\n      if (targetProps.dependencies) {\n        resource.node.addDependency(...targetProps.dependencies);\n      }\n\n      // based on the target type, add the the correct configurations array\n      switch (targetProps.type) {\n        case BucketNotificationDestinationType.LAMBDA:\n          this.lambdaNotifications.push({\n            ...commonConfig,\n            lambdaFunctionArn: targetProps.arn,\n          });\n          break;\n\n        case BucketNotificationDestinationType.QUEUE:\n          this.queueNotifications.push({\n            ...commonConfig,\n            queueArn: targetProps.arn,\n          });\n          break;\n\n        // TODO: re-add SNS support\n        case BucketNotificationDestinationType.TOPIC:\n          this.topicNotifications.push({\n            ...commonConfig,\n            topicArn: targetProps.arn,\n          });\n          break;\n\n        default:\n          throw new Error(\n            \"Unsupported notification target type:\" +\n              BucketNotificationDestinationType[targetProps.type],\n          );\n      }\n    }\n  }\n\n  public enableEventBridgeNotification() {\n    this.createResourceOnce();\n    this.eventBridgeEnabled = true;\n  }\n\n  /**\n   * Defines the bucket notifications resources in the stack only once.\n   * This is called lazily as we add notifications, so that if notifications are not added,\n   * there is no notifications resource.\n   */\n  private createResourceOnce() {\n    if (!this.resource) {\n      this.resource = new s3BucketNotification.S3BucketNotification(\n        this,\n        \"Resource\",\n        {\n          bucket: this.bucket.bucketName,\n          eventbridge: Lazy.anyValue({\n            produce: () => this.eventBridgeEnabled,\n          }),\n          lambdaFunction: Lazy.anyValue({\n            produce: () =>\n              this.lambdaNotifications.length > 0\n                ? this.lambdaNotifications.map((l) =>\n                    s3BucketNotification.s3BucketNotificationLambdaFunctionToTerraform(\n                      l,\n                    ),\n                  )\n                : undefined,\n          }),\n          queue: Lazy.anyValue({\n            produce: () =>\n              this.queueNotifications.length > 0\n                ? this.queueNotifications.map((q) =>\n                    s3BucketNotification.s3BucketNotificationQueueToTerraform(\n                      q,\n                    ),\n                  )\n                : undefined,\n          }),\n          topic: Lazy.anyValue({\n            produce: () =>\n              this.topicNotifications.length > 0\n                ? this.topicNotifications.map((t) =>\n                    s3BucketNotification.s3BucketNotificationTopicToTerraform(\n                      t,\n                    ),\n                  )\n                : undefined,\n          }),\n        },\n      );\n    }\n    return this.resource;\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    // Add dependency on bucket policy if it exists to avoid race conditions\n    // S3 does not allow calling PutBucketPolicy and PutBucketNotification APIs at the same time\n    // See https://github.com/aws/aws-cdk/issues/27600\n    // prepareStack are used here because bucket policy maybe added to construct after addition of notification resource.\n    // but we need this defined before stack Aspect maps construct dependencies to Terraform dependsOn\n    if (this.bucket.policy) {\n      this.node.addDependency(this.bucket.policy);\n    }\n    return {};\n  }\n}\n\ninterface CommonConfiguration {\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/s3_bucket_notification#id S3BucketNotification#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  readonly events: string[];\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/s3_bucket_notification#filter_prefix S3BucketNotification#filter_prefix}\n   */\n  readonly filterPrefix?: string;\n  /**\n   * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/s3_bucket_notification#filter_suffix S3BucketNotification#filter_suffix}\n   */\n  readonly filterSuffix?: string;\n}\n"]}

package/lib/aws/storage/bucket-policy.js

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

package/lib/aws/storage/bucket-source.js

@@ -75,5 +75,5 @@ class BucketSource extends aws_construct_1.AwsConstructBase {
 }
 exports.BucketSource = BucketSource;
 _a = JSII_RTTI_SYMBOL_1;
-BucketSource[_a] = { fqn: "terraconstructs.aws.storage.BucketSource", version: "0.0.17" };
+BucketSource[_a] = { fqn: "terraconstructs.aws.storage.BucketSource", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bucket-source.js","sourceRoot":"","sources":["../../../src/aws/storage/bucket-source.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport { s3Object } from \"@cdktf/provider-aws\";\nimport { TerraformAsset, AssetType, Fn, ITerraformDependable } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport * as mime from \"mime-types\";\nimport { normalPath, IBucket, AddSourceOptions } from \".\";\nimport {\n  AwsConstructBase,\n  IAwsConstruct,\n  AwsConstructProps,\n} from \"../aws-construct\";\n\nexport interface BucketSourceProps extends AddSourceOptions, AwsConstructProps {\n  /**\n   * Target bucket to upload to\n   */\n  readonly bucket: IBucket;\n}\n\nexport interface BucketObjectOutput {\n  /**\n   * The object source Hash\n   */\n  readonly sourceHash: string;\n}\n\nexport interface BucketSourceOutputs {\n  /**\n   * The objects uploaded to the bucket indexed by key\n   */\n  readonly objects: Record<string, BucketObjectOutput>;\n}\n\nexport interface IBucketSource extends IAwsConstruct {\n  readonly bucketSourceOutputs: BucketSourceOutputs;\n}\n\n/**\n * A Bucket Source which reads files from disk and creates uploads to s3.\n */\nexport class BucketSource extends AwsConstructBase implements IBucketSource {\n  public readonly objects: s3Object.S3Object[] = [];\n\n  private readonly _bucketSourceOutputs: BucketSourceOutputs;\n  public get bucketSourceOutputs(): BucketSourceOutputs {\n    return this._bucketSourceOutputs;\n  }\n\n  public get outputs(): Record<string, any> {\n    return this.bucketSourceOutputs;\n  }\n\n  private readonly dependsOn: ITerraformDependable[] = [];\n  private readonly resolvedPath: string;\n  private readonly prefix: string;\n  private _bucket: IBucket;\n\n  constructor(scope: Construct, id: string, props: BucketSourceProps) {\n    super(scope, id, props);\n\n    const { bucket, path: sourcePath, prefix } = props;\n\n    this._bucket = bucket;\n    this.dependsOn = props.dependsOn ?? [];\n    // should we support absolute paths? path.isAbsolute(props.path)?\n\n    this.resolvedPath = path.resolve(sourcePath);\n    this.prefix = prefix ?? \"\";\n\n    const asset = new TerraformAsset(this, \"PathAsset\", {\n      path: this.resolvedPath,\n      type: AssetType.DIRECTORY,\n    });\n    this.uploadAssetDir(sourcePath, asset.path);\n\n    this._bucketSourceOutputs = {\n      objects: this.objects.reduce(\n        (acc, obj) => {\n          acc[obj.key] = {\n            sourceHash: obj.sourceHash,\n          };\n          return acc;\n        },\n        {} as Record<string, BucketObjectOutput>,\n      ),\n    };\n  }\n\n  // TODO: Handle deployments with custom lambdas instead?\n  // https://github.com/aws/aws-cdk/blob/9946ab03672bf6664e8ec95a81ddb67c3bb2f63b/packages/%40aws-cdk/custom-resource-handlers/lib/aws-s3-deployment/bucket-deployment-handler/index.py\n  private uploadAssetDir(basePath: string, assetPath: string): void {\n    const files = fs.readdirSync(basePath, { withFileTypes: true });\n    for (const file of files) {\n      const baseFilename = path.join(basePath, file.name);\n      const assetFilename = path.join(assetPath, file.name);\n      if (file.isDirectory()) {\n        this.uploadAssetDir(baseFilename, assetFilename);\n      } else {\n        this.uploadAssetFile(baseFilename, assetFilename);\n      }\n    }\n  }\n\n  private uploadAssetFile(basePath: string, assetPath: string) {\n    let relativePath = path.join(\n      this.prefix,\n      basePath.replace(this.resolvedPath, \"\"),\n    );\n    const fileKey = normalPath(relativePath);\n\n    // copy from asset directory\n    this.objects.push(\n      new s3Object.S3Object(this, `File${fileKey.replace(/\\//g, \"--\")}`, {\n        key: fileKey,\n        bucket: this._bucket.bucketOutputs.name,\n        source: assetPath,\n        sourceHash: Fn.filemd5(assetPath),\n        contentType: mime.contentType(path.extname(assetPath)) || undefined,\n        dependsOn: this.dependsOn.length > 0 ? this.dependsOn : undefined,\n      }),\n    );\n  }\n}\n"]}

package/lib/aws/storage/bucket.js

@@ -396,7 +396,7 @@ class BucketBase extends aws_construct_1.AwsConstructBase {
 }
 exports.BucketBase = BucketBase;
 _a = JSII_RTTI_SYMBOL_1;
-BucketBase[_a] = { fqn: "terraconstructs.aws.storage.BucketBase", version: "0.0.17" };
+BucketBase[_a] = { fqn: "terraconstructs.aws.storage.BucketBase", version: "0.0.18" };
 /**
  * The `Bucket` provides an [AWS S3 Bucket](https://aws.amazon.com/s3/).
  *
@@ -890,7 +890,7 @@ class Bucket extends BucketBase {
 }
 exports.Bucket = Bucket;
 _b = JSII_RTTI_SYMBOL_1;
-Bucket[_b] = { fqn: "terraconstructs.aws.storage.Bucket", version: "0.0.17" };
+Bucket[_b] = { fqn: "terraconstructs.aws.storage.Bucket", version: "0.0.18" };
 /**
  * Storage class to move an object to
  */

package/lib/aws/storage/notification-targets/function.js

@@ -44,5 +44,5 @@ class FunctionDestination {
 }
 exports.FunctionDestination = FunctionDestination;
 _a = JSII_RTTI_SYMBOL_1;
-FunctionDestination[_a] = { fqn: "terraconstructs.aws.storage.targets.FunctionDestination", version: "0.0.17" };
+FunctionDestination[_a] = { fqn: "terraconstructs.aws.storage.targets.FunctionDestination", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/aws/storage/notification-targets/queue.js

@@ -54,5 +54,5 @@ class QueueDestination {
 }
 exports.QueueDestination = QueueDestination;
 _a = JSII_RTTI_SYMBOL_1;
-QueueDestination[_a] = { fqn: "terraconstructs.aws.storage.targets.QueueDestination", version: "0.0.17" };
+QueueDestination[_a] = { fqn: "terraconstructs.aws.storage.targets.QueueDestination", version: "0.0.18" };
 //# sourceMappingURL=data:application/json;base64,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