terraconstructs 0.0.8

package/lib/aws/storage/bucket-notifications.d.ts

@@ -0,0 +1,58 @@
+import { s3BucketNotification } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { IBucket, EventType, NotificationKeyFilter } from "./bucket";
+import { IBucketNotificationDestination } from "./bucket-destination";
+export interface NotificationsProps extends AwsConstructProps {
+    /**
+     * The bucket to manage notifications for.
+     */
+    readonly bucket: IBucket;
+}
+/**
+ * A custom CloudFormation resource that updates bucket notifications for a
+ * bucket. The reason we need it is because the AWS::S3::Bucket notification
+ * configuration is defined on the bucket itself, which makes it impossible to
+ * provision notifications at the same time as the target (since
+ * PutBucketNotifications validates the targets).
+ *
+ * Since only a single BucketNotifications resource is allowed for each Bucket,
+ * this construct is not exported in the public API of this module. Instead, it
+ * is created just-in-time by `s3.Bucket.onEvent`, so a 1:1 relationship is
+ * ensured.
+ *
+ * @see
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-notificationconfig.html
+ */
+export declare class BucketNotifications extends AwsConstructBase {
+    resource?: s3BucketNotification.S3BucketNotification;
+    get outputs(): Record<string, any>;
+    private eventBridgeEnabled;
+    private readonly lambdaNotifications;
+    private readonly queueNotifications;
+    private readonly topicNotifications;
+    private readonly bucket;
+    constructor(scope: Construct, id: string, props: NotificationsProps);
+    /**
+     * Adds a notification subscription for this bucket.
+     * If this is the first notification, a BucketNotification resource is added to the stack.
+     *
+     * @param event The type of event
+     * @param target The target construct
+     * @param filters A set of S3 key filters
+     */
+    addNotification(event: EventType, target: IBucketNotificationDestination, ...filters: NotificationKeyFilter[]): void;
+    enableEventBridgeNotification(): void;
+    /**
+     * Defines the bucket notifications resources in the stack only once.
+     * This is called lazily as we add notifications, so that if notifications are not added,
+     * there is no notifications resource.
+     */
+    private createResourceOnce;
+    /**
+     * Adds resource to the Terraform JSON output at Synth time.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform(): any;
+}

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

@@ -0,0 +1,169 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketNotifications = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+const bucket_destination_1 = require("./bucket-destination");
+/**
+ * A custom CloudFormation resource that updates bucket notifications for a
+ * bucket. The reason we need it is because the AWS::S3::Bucket notification
+ * configuration is defined on the bucket itself, which makes it impossible to
+ * provision notifications at the same time as the target (since
+ * PutBucketNotifications validates the targets).
+ *
+ * Since only a single BucketNotifications resource is allowed for each Bucket,
+ * this construct is not exported in the public API of this module. Instead, it
+ * is created just-in-time by `s3.Bucket.onEvent`, so a 1:1 relationship is
+ * ensured.
+ *
+ * @see
+ * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-notificationconfig.html
+ */
+class BucketNotifications extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {};
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.eventBridgeEnabled = false;
+        this.lambdaNotifications = new Array();
+        this.queueNotifications = new Array();
+        this.topicNotifications = new Array();
+        this.bucket = props.bucket;
+    }
+    /**
+     * Adds a notification subscription for this bucket.
+     * If this is the first notification, a BucketNotification resource is added to the stack.
+     *
+     * @param event The type of event
+     * @param target The target construct
+     * @param filters A set of S3 key filters
+     */
+    addNotification(event, target, ...filters) {
+        const resource = this.createResourceOnce();
+        // TODO: Seems Terraform provider does not have limitations on prefix and suffix?
+        // let hasPrefix = false;
+        // let hasSuffix = false;
+        for (const filter of filters) {
+            // if (!filter.suffix && !filter.prefix) {
+            //   throw new Error(
+            //     "NotificationKeyFilter must specify `prefix` and/or `suffix`",
+            //   );
+            // }
+            // if (filter.suffix) {
+            //   if (hasSuffix) {
+            //     throw new Error(
+            //       "Cannot specify more than one suffix rule in a filter.",
+            //     );
+            //   }
+            //   hasSuffix = true;
+            // }
+            // if (filter.prefix) {
+            //   if (hasPrefix) {
+            //     throw new Error(
+            //       "Cannot specify more than one prefix rule in a filter.",
+            //     );
+            //   }
+            //   hasPrefix = true;
+            // }
+            // resolve target. this also provides an opportunity for the target to e.g. update
+            // policies to allow this notification to happen.
+            const targetProps = target.bind(this, this.bucket);
+            const commonConfig = {
+                events: [event],
+                id: filter.id,
+                filterPrefix: filter.prefix,
+                filterSuffix: filter.suffix,
+            };
+            // if the target specifies any dependencies, add them here.
+            // for example, the SNS topic policy must be created /before/ the notification resource.
+            // otherwise, S3 won't be able to confirm the subscription.
+            if (targetProps.dependencies) {
+                resource.node.addDependency(...targetProps.dependencies);
+            }
+            // based on the target type, add the the correct configurations array
+            switch (targetProps.type) {
+                case bucket_destination_1.BucketNotificationDestinationType.LAMBDA:
+                    this.lambdaNotifications.push({
+                        ...commonConfig,
+                        lambdaFunctionArn: targetProps.arn,
+                    });
+                    break;
+                case bucket_destination_1.BucketNotificationDestinationType.QUEUE:
+                    this.queueNotifications.push({
+                        ...commonConfig,
+                        queueArn: targetProps.arn,
+                    });
+                    break;
+                // TODO: re-add SNS support
+                case bucket_destination_1.BucketNotificationDestinationType.TOPIC:
+                    this.topicNotifications.push({
+                        ...commonConfig,
+                        topicArn: targetProps.arn,
+                    });
+                    break;
+                default:
+                    throw new Error("Unsupported notification target type:" +
+                        bucket_destination_1.BucketNotificationDestinationType[targetProps.type]);
+            }
+        }
+    }
+    enableEventBridgeNotification() {
+        this.createResourceOnce();
+        this.eventBridgeEnabled = true;
+    }
+    /**
+     * Defines the bucket notifications resources in the stack only once.
+     * This is called lazily as we add notifications, so that if notifications are not added,
+     * there is no notifications resource.
+     */
+    createResourceOnce() {
+        if (!this.resource) {
+            this.resource = new provider_aws_1.s3BucketNotification.S3BucketNotification(this, "Resource", {
+                bucket: this.bucket.bucketName,
+                eventbridge: cdktf_1.Lazy.anyValue({
+                    produce: () => this.eventBridgeEnabled,
+                }),
+                lambdaFunction: cdktf_1.Lazy.anyValue({
+                    produce: () => this.lambdaNotifications.length > 0
+                        ? this.lambdaNotifications.map((l) => provider_aws_1.s3BucketNotification.s3BucketNotificationLambdaFunctionToTerraform(l))
+                        : undefined,
+                }),
+                queue: cdktf_1.Lazy.anyValue({
+                    produce: () => this.queueNotifications.length > 0
+                        ? this.queueNotifications.map((q) => provider_aws_1.s3BucketNotification.s3BucketNotificationQueueToTerraform(q))
+                        : undefined,
+                }),
+                topic: cdktf_1.Lazy.anyValue({
+                    produce: () => this.topicNotifications.length > 0
+                        ? this.topicNotifications.map((t) => provider_aws_1.s3BucketNotification.s3BucketNotificationTopicToTerraform(t))
+                        : undefined,
+                }),
+            });
+        }
+        return this.resource;
+    }
+    /**
+     * Adds resource to the Terraform JSON output at Synth time.
+     *
+     * called by TerraformStack.prepareStack()
+     */
+    toTerraform() {
+        // Add dependency on bucket policy if it exists to avoid race conditions
+        // S3 does not allow calling PutBucketPolicy and PutBucketNotification APIs at the same time
+        // See https://github.com/aws/aws-cdk/issues/27600
+        // prepareStack are used here because bucket policy maybe added to construct after addition of notification resource.
+        // but we need this defined before stack Aspect maps construct dependencies to Terraform dependsOn
+        if (this.bucket.policy) {
+            this.node.addDependency(this.bucket.policy);
+        }
+        return {};
+    }
+}
+exports.BucketNotifications = BucketNotifications;
+_a = JSII_RTTI_SYMBOL_1;
+BucketNotifications[_a] = { fqn: "terraconstructs.aws.storage.BucketNotifications", version: "0.0.8" };
+//# 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-perms.d.ts

@@ -0,0 +1,9 @@
+export declare const BUCKET_READ_ACTIONS: string[];
+export declare const BUCKET_READ_METADATA_ACTIONS: string[];
+export declare const LEGACY_BUCKET_PUT_ACTIONS: string[];
+export declare const BUCKET_PUT_ACTIONS: string[];
+export declare const BUCKET_PUT_ACL_ACTIONS: string[];
+export declare const BUCKET_PUT_POLICY_ACTIONS: string[];
+export declare const BUCKET_DELETE_ACTIONS: string[];
+export declare const KEY_READ_ACTIONS: string[];
+export declare const KEY_WRITE_ACTIONS: string[];

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_WRITE_ACTIONS = exports.KEY_READ_ACTIONS = exports.BUCKET_DELETE_ACTIONS = exports.BUCKET_PUT_POLICY_ACTIONS = exports.BUCKET_PUT_ACL_ACTIONS = exports.BUCKET_PUT_ACTIONS = exports.LEGACY_BUCKET_PUT_ACTIONS = exports.BUCKET_READ_METADATA_ACTIONS = exports.BUCKET_READ_ACTIONS = void 0;
+// ref: https://github.com/aws/aws-cdk/blob/v2.160.0/packages/aws-cdk-lib/aws-s3/lib/perms.ts
+exports.BUCKET_READ_ACTIONS = [
+    "s3:GetObject*",
+    "s3:GetBucket*",
+    "s3:List*",
+];
+exports.BUCKET_READ_METADATA_ACTIONS = ["s3:GetBucket*", "s3:List*"];
+exports.LEGACY_BUCKET_PUT_ACTIONS = ["s3:PutObject*", "s3:Abort*"];
+exports.BUCKET_PUT_ACTIONS = [
+    "s3:PutObject",
+    "s3:PutObjectLegalHold",
+    "s3:PutObjectRetention",
+    "s3:PutObjectTagging",
+    "s3:PutObjectVersionTagging",
+    "s3:Abort*",
+];
+exports.BUCKET_PUT_ACL_ACTIONS = [
+    "s3:PutObjectAcl",
+    "s3:PutObjectVersionAcl",
+];
+exports.BUCKET_PUT_POLICY_ACTIONS = ["s3:PutBucketPolicy"];
+exports.BUCKET_DELETE_ACTIONS = ["s3:DeleteObject*"];
+exports.KEY_READ_ACTIONS = ["kms:Decrypt", "kms:DescribeKey"];
+exports.KEY_WRITE_ACTIONS = [
+    "kms:Encrypt",
+    "kms:ReEncrypt*",
+    "kms:GenerateDataKey*",
+    "kms:Decrypt", // required for multipart uploads. Refer https://aws.amazon.com/premiumsupport/knowledge-center/s3-multipart-kms-decrypt/
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/storage/bucket-policy.d.ts

@@ -0,0 +1,51 @@
+import { s3BucketPolicy } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructProps, AwsConstructBase } from "../aws-construct";
+import { IBucket } from "./bucket";
+import { PolicyDocument } from "../iam";
+export interface BucketPolicyProps extends AwsConstructProps {
+    /**
+     * The Amazon S3 bucket that the policy applies to.
+     */
+    readonly bucket: IBucket;
+}
+/**
+ * The bucket policy for an Amazon S3 bucket
+ *
+ * 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.
+ *
+ * The bucket policy method is implemented differently than `addToResourcePolicy()`
+ * as `BucketPolicy()` creates a new policy without knowing one earlier existed.
+ * e.g. if during Bucket creation, if `autoDeleteObject:true`, these policies are
+ * added to the bucket policy:
+ *    ["s3:DeleteObject*", "s3:GetBucket*", "s3:List*", "s3:PutBucketPolicy"],
+ * and when you add a new BucketPolicy with ["s3:GetObject", "s3:ListBucket"] on
+ * this existing bucket, invoking `BucketPolicy()` will create a new Policy
+ * without knowing one earlier exists already, so it creates a new one.
+ * In this case, the custom resource handler will not have access to
+ * `s3:GetBucketTagging` action which will cause failure during deletion of stack.
+ *
+ * Hence its strongly recommended to use `addToResourcePolicy()` method to add
+ * new permissions to existing policy.
+ *
+ */
+export declare class BucketPolicy extends AwsConstructBase {
+    readonly resource: s3BucketPolicy.S3BucketPolicy;
+    get outputs(): Record<string, any>;
+    /**
+     * A policy document containing permissions to add to the specified bucket.
+     * For more information, see Access Policy Language Overview in the Amazon
+     * Simple Storage Service Developer Guide.
+     */
+    readonly document: PolicyDocument;
+    /** The Bucket this Policy applies to. */
+    readonly bucket: IBucket;
+    constructor(scope: Construct, id: string, props: BucketPolicyProps);
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketPolicy = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+const iam_1 = require("../iam");
+/**
+ * The bucket policy for an Amazon S3 bucket
+ *
+ * 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.
+ *
+ * The bucket policy method is implemented differently than `addToResourcePolicy()`
+ * as `BucketPolicy()` creates a new policy without knowing one earlier existed.
+ * e.g. if during Bucket creation, if `autoDeleteObject:true`, these policies are
+ * added to the bucket policy:
+ *    ["s3:DeleteObject*", "s3:GetBucket*", "s3:List*", "s3:PutBucketPolicy"],
+ * and when you add a new BucketPolicy with ["s3:GetObject", "s3:ListBucket"] on
+ * this existing bucket, invoking `BucketPolicy()` will create a new Policy
+ * without knowing one earlier exists already, so it creates a new one.
+ * In this case, the custom resource handler will not have access to
+ * `s3:GetBucketTagging` action which will cause failure during deletion of stack.
+ *
+ * Hence its strongly recommended to use `addToResourcePolicy()` method to add
+ * new permissions to existing policy.
+ *
+ */
+class BucketPolicy extends aws_construct_1.AwsConstructBase {
+    get outputs() {
+        return {};
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.bucket = props.bucket;
+        this.document = new iam_1.PolicyDocument(this, "Policy");
+        this.resource = new provider_aws_1.s3BucketPolicy.S3BucketPolicy(this, "Resource", {
+            bucket: this.bucket.bucketName,
+            policy: this.document.json,
+        });
+    }
+}
+exports.BucketPolicy = BucketPolicy;
+_a = JSII_RTTI_SYMBOL_1;
+BucketPolicy[_a] = { fqn: "terraconstructs.aws.storage.BucketPolicy", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/storage/bucket-source.d.ts

@@ -0,0 +1,41 @@
+import { s3Object } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IBucket, AddSourceOptions } from ".";
+import { AwsConstructBase, IAwsConstruct, AwsConstructProps } from "../aws-construct";
+export interface BucketSourceProps extends AddSourceOptions, AwsConstructProps {
+    /**
+     * Target bucket to upload to
+     */
+    readonly bucket: IBucket;
+}
+export interface BucketObjectOutput {
+    /**
+     * The object source Hash
+     */
+    readonly sourceHash: string;
+}
+export interface BucketSourceOutputs {
+    /**
+     * The objects uploaded to the bucket indexed by key
+     */
+    readonly objects: Record<string, BucketObjectOutput>;
+}
+export interface IBucketSource extends IAwsConstruct {
+    readonly bucketSourceOutputs: BucketSourceOutputs;
+}
+/**
+ * A Bucket Source which reads files from disk and creates uploads to s3.
+ */
+export declare class BucketSource extends AwsConstructBase implements IBucketSource {
+    readonly objects: s3Object.S3Object[];
+    private readonly _bucketSourceOutputs;
+    get bucketSourceOutputs(): BucketSourceOutputs;
+    get outputs(): Record<string, any>;
+    private readonly dependsOn;
+    private readonly resolvedPath;
+    private readonly prefix;
+    private _bucket;
+    constructor(scope: Construct, id: string, props: BucketSourceProps);
+    private uploadAssetDir;
+    private uploadAssetFile;
+}

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

@@ -0,0 +1,79 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketSource = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs = require("fs");
+const path = require("path");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const mime = require("mime-types");
+const _1 = require(".");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * A Bucket Source which reads files from disk and creates uploads to s3.
+ */
+class BucketSource extends aws_construct_1.AwsConstructBase {
+    get bucketSourceOutputs() {
+        return this._bucketSourceOutputs;
+    }
+    get outputs() {
+        return this.bucketSourceOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.objects = [];
+        this.dependsOn = [];
+        const { bucket, path: sourcePath, prefix } = props;
+        this._bucket = bucket;
+        this.dependsOn = props.dependsOn ?? [];
+        // should we support absolute paths? path.isAbsolute(props.path)?
+        this.resolvedPath = path.resolve(sourcePath);
+        this.prefix = prefix ?? "";
+        const asset = new cdktf_1.TerraformAsset(this, "PathAsset", {
+            path: this.resolvedPath,
+            type: cdktf_1.AssetType.DIRECTORY,
+        });
+        this.uploadAssetDir(sourcePath, asset.path);
+        this._bucketSourceOutputs = {
+            objects: this.objects.reduce((acc, obj) => {
+                acc[obj.key] = {
+                    sourceHash: obj.sourceHash,
+                };
+                return acc;
+            }, {}),
+        };
+    }
+    // TODO: Handle deployments with custom lambdas instead?
+    // https://github.com/aws/aws-cdk/blob/9946ab03672bf6664e8ec95a81ddb67c3bb2f63b/packages/%40aws-cdk/custom-resource-handlers/lib/aws-s3-deployment/bucket-deployment-handler/index.py
+    uploadAssetDir(basePath, assetPath) {
+        const files = fs.readdirSync(basePath, { withFileTypes: true });
+        for (const file of files) {
+            const baseFilename = path.join(basePath, file.name);
+            const assetFilename = path.join(assetPath, file.name);
+            if (file.isDirectory()) {
+                this.uploadAssetDir(baseFilename, assetFilename);
+            }
+            else {
+                this.uploadAssetFile(baseFilename, assetFilename);
+            }
+        }
+    }
+    uploadAssetFile(basePath, assetPath) {
+        let relativePath = path.join(this.prefix, basePath.replace(this.resolvedPath, ""));
+        const fileKey = (0, _1.normalPath)(relativePath);
+        // copy from asset directory
+        this.objects.push(new provider_aws_1.s3Object.S3Object(this, `File${fileKey.replace(/\//g, "--")}`, {
+            key: fileKey,
+            bucket: this._bucket.bucketOutputs.name,
+            source: assetPath,
+            sourceHash: cdktf_1.Fn.filemd5(assetPath),
+            contentType: mime.contentType(path.extname(assetPath)) || undefined,
+            dependsOn: this.dependsOn.length > 0 ? this.dependsOn : undefined,
+        }));
+    }
+}
+exports.BucketSource = BucketSource;
+_a = JSII_RTTI_SYMBOL_1;
+BucketSource[_a] = { fqn: "terraconstructs.aws.storage.BucketSource", version: "0.0.8" };
+//# 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"]}