truemark-cdk-lib 1.6.5 → 1.6.6

package/aws-s3/lib/cloud-front-bucket.d.ts

@@ -5,6 +5,7 @@ import { BucketDeployment, ISource } from "aws-cdk-lib/aws-s3-deployment";
 import { Duration, RemovalPolicy } from "aws-cdk-lib";
 import { ExtendedConstruct, ExtendedConstructProps } from "../../aws-cdk";
 import { S3Origin } from "aws-cdk-lib/aws-cloudfront-origins";
+import { Grant, IGrantable } from "aws-cdk-lib/aws-iam";
 /**
  * Properties for CloudFrontBucket.
  */
@@ -98,4 +99,81 @@ export declare class CloudFrontBucket extends ExtendedConstruct {
      * Helper method to return a CloudFront Origin for this bucket.
      */
     toOrigin(): S3Origin;
+    /**
+     * Grant read permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If encryption is used, permission to use the key to decrypt the contents
+     * of the bucket will also be granted to the same principal.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantRead(identity: IGrantable, objectsKeyPattern?: any): Grant;
+    /**
+     * Grant write permissions to this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     * @param allowedActionPatterns Restrict the permissions to certain list of action patterns
+     */
+    grantWrite(identity: IGrantable, objectsKeyPattern?: any, allowedActionPatterns?: string[]): Grant;
+    /**
+     * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPut(identity: IGrantable, objectsKeyPattern?: any): Grant;
+    /**
+     * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.
+     *
+     * If your application has the '@aws-cdk/aws-s3:grantWriteWithoutAcl' feature flag set,
+     * calling `grantWrite` or `grantReadWrite` no longer grants permissions to modify the ACLs of the objects;
+     * in this case, if you need to modify object ACLs, call this method explicitly.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPutAcl(identity: IGrantable, objectsKeyPattern?: string): Grant;
+    /**
+     * Grants s3:DeleteObject* permission to an IAM principal for objects
+     * in this bucket.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantDelete(identity: IGrantable, objectsKeyPattern?: any): Grant;
+    /**
+     * Grants read/write permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to use the key for
+     * encrypt/decrypt will also be granted.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantReadWrite(identity: IGrantable, objectsKeyPattern?: any): Grant;
 }

package/aws-s3/lib/cloud-front-bucket.js

@@ -117,6 +117,95 @@ class CloudFrontBucket extends aws_cdk_1.ExtendedConstruct {
             originAccessIdentity: this.originAccessIdentity
         });
     }
+    /**
+     * Grant read permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If encryption is used, permission to use the key to decrypt the contents
+     * of the bucket will also be granted to the same principal.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantRead(identity, objectsKeyPattern) {
+        return this.bucket.grantRead(identity, objectsKeyPattern);
+    }
+    /**
+     * Grant write permissions to this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     * @param allowedActionPatterns Restrict the permissions to certain list of action patterns
+     */
+    grantWrite(identity, objectsKeyPattern, allowedActionPatterns) {
+        return this.bucket.grantWrite(identity, objectsKeyPattern, allowedActionPatterns);
+    }
+    /**
+     * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPut(identity, objectsKeyPattern) {
+        return this.bucket.grantPut(identity, objectsKeyPattern);
+    }
+    /**
+     * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.
+     *
+     * If your application has the '@aws-cdk/aws-s3:grantWriteWithoutAcl' feature flag set,
+     * calling `grantWrite` or `grantReadWrite` no longer grants permissions to modify the ACLs of the objects;
+     * in this case, if you need to modify object ACLs, call this method explicitly.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPutAcl(identity, objectsKeyPattern) {
+        return this.bucket.grantPutAcl(identity, objectsKeyPattern);
+    }
+    /**
+     * Grants s3:DeleteObject* permission to an IAM principal for objects
+     * in this bucket.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantDelete(identity, objectsKeyPattern) {
+        return this.bucket.grantDelete(identity, objectsKeyPattern);
+    }
+    /**
+     * Grants read/write permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to use the key for
+     * encrypt/decrypt will also be granted.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantReadWrite(identity, objectsKeyPattern) {
+        return this.bucket.grantReadWrite(identity, objectsKeyPattern);
+    }
 }
 exports.CloudFrontBucket = CloudFrontBucket;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-front-bucket.js","sourceRoot":"","sources":["cloud-front-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from \"constructs\";\nimport {BlockPublicAccess, Bucket, BucketEncryption} from \"aws-cdk-lib/aws-s3\";\nimport {OriginAccessIdentity} from \"aws-cdk-lib/aws-cloudfront\";\nimport {BucketDeployment, CacheControl, ISource, Source} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {Duration, RemovalPolicy} from \"aws-cdk-lib\";\nimport {ExtendedConstruct, ExtendedConstructProps, StandardTags} from \"../../aws-cdk\";\nimport {LibStandardTags} from \"../../truemark\";\nimport {S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\n\n/**\n * Properties for CloudFrontBucket.\n */\nexport interface CloudFrontBucketProps extends ExtendedConstructProps {\n\n  /**\n   * Policy to apply when the bucket is removed from this stack.\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Whether all objects should be automatically deleted when the bucket is removed from the stack or when the stack is deleted.\n   * Requires the removalPolicy to be set to RemovalPolicy.DESTROY. Default is false.\n   *\n   * @default false\n   */\n  readonly autoDeleteObjects?: boolean;\n\n  /**\n   * Whether this bucket should have versioning turned on or not. Default is false.\n   *\n   * @default false\n   */\n  readonly versioned?: boolean;\n\n  /**\n   * Whether this bucket should have transfer acceleration turned on or not. Default is false.\n   *\n   * @default false\n   */\n  readonly transferAcceleration?: boolean;\n\n  /**\n   * Optional bucket name. If not provided, a name will be generated.\n   */\n  readonly bucketName?: string;\n}\n\n/**\n * Simple Construct for creating buckets that will be accessed directly by CloudFront as an Origin.\n */\nexport class CloudFrontBucket extends ExtendedConstruct {\n\n  private deployCount: number = 0;\n\n  readonly bucket: Bucket;\n  readonly bucketName: string;\n  readonly bucketArn: string;\n  readonly originAccessIdentity: OriginAccessIdentity;\n  readonly originAccessIdentityId: string;\n\n  private nextDeployCount(): string {\n    let current = this.deployCount++;\n    return current === 0 ? '' : `${current}`;\n  }\n\n  constructor(scope: Construct, id: string, props?: CloudFrontBucketProps) {\n    super(scope, id, {standardTags: StandardTags.merge(props?.standardTags, LibStandardTags)});\n\n    const removalPolicy = props?.removalPolicy ?? RemovalPolicy.RETAIN;\n    const autoDeleteObjects = (props?.autoDeleteObjects ?? false) && removalPolicy === RemovalPolicy.DESTROY;\n\n    this.bucket = new Bucket(this, \"Default\", {\n      encryption: BucketEncryption.S3_MANAGED, // CloudFront cannot use KMS with S3\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy,\n      autoDeleteObjects,\n      versioned: props?.versioned ?? false,\n      transferAcceleration: props?.transferAcceleration ?? false,\n      bucketName: props?.bucketName\n    });\n    this.bucketName = this.bucket.bucketName;\n    this.bucketArn = this.bucket.bucketArn;\n    this.originAccessIdentity = new OriginAccessIdentity(this, \"Access\", {\n      comment: `S3 bucket ${this.bucket.bucketName}`\n    });\n    this.originAccessIdentityId = this.originAccessIdentity.originAccessIdentityId;\n    this.bucket.grantRead(this.originAccessIdentity);\n  }\n\n  /**\n   * Helper method to deploy local assets to the created bucket. Ths function assumes\n   * CloudFront invalidation requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param paths the paths to the local assets\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deployPaths(paths: string[], maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return new BucketDeployment(this, `Deploy${this.nextDeployCount()}`, {\n      sources: paths.map(path => Source.asset(path)),\n      destinationBucket: this.bucket,\n      prune: prune ?? false,\n      cacheControl: [\n        CacheControl.setPublic(),\n        CacheControl.maxAge(maxAge ?? Duration.minutes(15)),\n        CacheControl.sMaxAge(sMaxAge ?? Duration.days(7))\n      ]\n    });\n  }\n\n  /**\n   * Helper method to deploy local assets to the created bucket. Ths function assumes\n   * CloudFront invalidation requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param path the path to the local assets\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deployPath(path: string, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return this.deployPaths([path], maxAge, sMaxAge, prune);\n  }\n\n  /**\n   * Helper method to assets to the created bucket. This function assumes CloudFront invalidation\n   * requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param sources the sources to deploy\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deploySources(sources: ISource[], maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return new BucketDeployment(this, `Deploy${this.nextDeployCount()}`, {\n      sources: sources,\n      destinationBucket: this.bucket,\n      prune: prune ?? false,\n      cacheControl: [\n        CacheControl.setPublic(),\n        CacheControl.maxAge(maxAge ?? Duration.minutes(15)),\n        CacheControl.sMaxAge(sMaxAge ?? Duration.days(7))\n      ]\n    });\n  }\n\n  /**\n   * Helper method to assets to the created bucket. This function assumes CloudFront invalidation\n   * requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param source the source to deploy\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deploySource(source: ISource, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return this.deploySources([source], maxAge, sMaxAge, prune);\n  }\n\n  /**\n   * Helper method to return a CloudFront Origin for this bucket.\n   */\n  toOrigin(): S3Origin {\n    return new S3Origin(this.bucket, {\n      originAccessIdentity: this.originAccessIdentity\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cloud-front-bucket.js","sourceRoot":"","sources":["cloud-front-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from \"constructs\";\nimport {BlockPublicAccess, Bucket, BucketEncryption} from \"aws-cdk-lib/aws-s3\";\nimport {OriginAccessIdentity} from \"aws-cdk-lib/aws-cloudfront\";\nimport {BucketDeployment, CacheControl, ISource, Source} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {Duration, RemovalPolicy} from \"aws-cdk-lib\";\nimport {ExtendedConstruct, ExtendedConstructProps, StandardTags} from \"../../aws-cdk\";\nimport {LibStandardTags} from \"../../truemark\";\nimport {S3Origin} from \"aws-cdk-lib/aws-cloudfront-origins\";\nimport {Grant, IGrantable} from \"aws-cdk-lib/aws-iam\";\nimport * as iam from \"aws-cdk-lib/aws-iam\";\n\n/**\n * Properties for CloudFrontBucket.\n */\nexport interface CloudFrontBucketProps extends ExtendedConstructProps {\n\n  /**\n   * Policy to apply when the bucket is removed from this stack.\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Whether all objects should be automatically deleted when the bucket is removed from the stack or when the stack is deleted.\n   * Requires the removalPolicy to be set to RemovalPolicy.DESTROY. Default is false.\n   *\n   * @default false\n   */\n  readonly autoDeleteObjects?: boolean;\n\n  /**\n   * Whether this bucket should have versioning turned on or not. Default is false.\n   *\n   * @default false\n   */\n  readonly versioned?: boolean;\n\n  /**\n   * Whether this bucket should have transfer acceleration turned on or not. Default is false.\n   *\n   * @default false\n   */\n  readonly transferAcceleration?: boolean;\n\n  /**\n   * Optional bucket name. If not provided, a name will be generated.\n   */\n  readonly bucketName?: string;\n}\n\n/**\n * Simple Construct for creating buckets that will be accessed directly by CloudFront as an Origin.\n */\nexport class CloudFrontBucket extends ExtendedConstruct {\n\n  private deployCount: number = 0;\n\n  readonly bucket: Bucket;\n  readonly bucketName: string;\n  readonly bucketArn: string;\n  readonly originAccessIdentity: OriginAccessIdentity;\n  readonly originAccessIdentityId: string;\n\n  private nextDeployCount(): string {\n    let current = this.deployCount++;\n    return current === 0 ? '' : `${current}`;\n  }\n\n  constructor(scope: Construct, id: string, props?: CloudFrontBucketProps) {\n    super(scope, id, {standardTags: StandardTags.merge(props?.standardTags, LibStandardTags)});\n\n    const removalPolicy = props?.removalPolicy ?? RemovalPolicy.RETAIN;\n    const autoDeleteObjects = (props?.autoDeleteObjects ?? false) && removalPolicy === RemovalPolicy.DESTROY;\n\n    this.bucket = new Bucket(this, \"Default\", {\n      encryption: BucketEncryption.S3_MANAGED, // CloudFront cannot use KMS with S3\n      blockPublicAccess: BlockPublicAccess.BLOCK_ALL,\n      removalPolicy,\n      autoDeleteObjects,\n      versioned: props?.versioned ?? false,\n      transferAcceleration: props?.transferAcceleration ?? false,\n      bucketName: props?.bucketName\n    });\n    this.bucketName = this.bucket.bucketName;\n    this.bucketArn = this.bucket.bucketArn;\n    this.originAccessIdentity = new OriginAccessIdentity(this, \"Access\", {\n      comment: `S3 bucket ${this.bucket.bucketName}`\n    });\n    this.originAccessIdentityId = this.originAccessIdentity.originAccessIdentityId;\n    this.bucket.grantRead(this.originAccessIdentity);\n  }\n\n  /**\n   * Helper method to deploy local assets to the created bucket. Ths function assumes\n   * CloudFront invalidation requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param paths the paths to the local assets\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deployPaths(paths: string[], maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return new BucketDeployment(this, `Deploy${this.nextDeployCount()}`, {\n      sources: paths.map(path => Source.asset(path)),\n      destinationBucket: this.bucket,\n      prune: prune ?? false,\n      cacheControl: [\n        CacheControl.setPublic(),\n        CacheControl.maxAge(maxAge ?? Duration.minutes(15)),\n        CacheControl.sMaxAge(sMaxAge ?? Duration.days(7))\n      ]\n    });\n  }\n\n  /**\n   * Helper method to deploy local assets to the created bucket. Ths function assumes\n   * CloudFront invalidation requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param path the path to the local assets\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deployPath(path: string, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return this.deployPaths([path], maxAge, sMaxAge, prune);\n  }\n\n  /**\n   * Helper method to assets to the created bucket. This function assumes CloudFront invalidation\n   * requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param sources the sources to deploy\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deploySources(sources: ISource[], maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return new BucketDeployment(this, `Deploy${this.nextDeployCount()}`, {\n      sources: sources,\n      destinationBucket: this.bucket,\n      prune: prune ?? false,\n      cacheControl: [\n        CacheControl.setPublic(),\n        CacheControl.maxAge(maxAge ?? Duration.minutes(15)),\n        CacheControl.sMaxAge(sMaxAge ?? Duration.days(7))\n      ]\n    });\n  }\n\n  /**\n   * Helper method to assets to the created bucket. This function assumes CloudFront invalidation\n   * requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param source the source to deploy\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune true to prune old files; default is false\n   */\n  deploySource(source: ISource, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return this.deploySources([source], maxAge, sMaxAge, prune);\n  }\n\n  /**\n   * Helper method to return a CloudFront Origin for this bucket.\n   */\n  toOrigin(): S3Origin {\n    return new S3Origin(this.bucket, {\n      originAccessIdentity: this.originAccessIdentity\n    });\n  }\n\n  /**\n   * Grant read permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If encryption is used, permission to use the key to decrypt the contents\n   * of the bucket will also be granted to the same principal.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantRead(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantRead(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grant write permissions to this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   *\n   * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,\n   * which could be used to grant read/write object access to IAM principals in other accounts.\n   * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,\n   * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`\n   * in the `context` key of your cdk.json file.\n   * If you've already updated, but still need the principal to have permissions to modify the ACLs,\n   * use the `grantPutAcl` method.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   * @param allowedActionPatterns Restrict the permissions to certain list of action patterns\n   */\n  grantWrite(identity: IGrantable, objectsKeyPattern?: any, allowedActionPatterns?: string[]): Grant {\n    return this.bucket.grantWrite(identity, objectsKeyPattern, allowedActionPatterns);\n  }\n\n  /**\n   * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantPut(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantPut(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.\n   *\n   * If your application has the '@aws-cdk/aws-s3:grantWriteWithoutAcl' feature flag set,\n   * calling `grantWrite` or `grantReadWrite` no longer grants permissions to modify the ACLs of the objects;\n   * in this case, if you need to modify object ACLs, call this method explicitly.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantPutAcl(identity: IGrantable, objectsKeyPattern?: string): Grant {\n    return this.bucket.grantPutAcl(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grants s3:DeleteObject* permission to an IAM principal for objects\n   * in this bucket.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantDelete(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantDelete(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grants read/write permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to use the key for\n   * encrypt/decrypt will also be granted.\n   *\n   * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,\n   * which could be used to grant read/write object access to IAM principals in other accounts.\n   * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,\n   * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`\n   * in the `context` key of your cdk.json file.\n   * If you've already updated, but still need the principal to have permissions to modify the ACLs,\n   * use the `grantPutAcl` method.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantReadWrite(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantReadWrite(identity, objectsKeyPattern);\n  }\n\n}\n"]}

package/aws-s3/lib/website-bucket.d.ts

@@ -4,6 +4,7 @@ import { LatencyARecord, WeightedARecord } from "../../aws-route53";
 import { ARecord, IHostedZone } from "aws-cdk-lib/aws-route53";
 import { RemovalPolicy, Duration } from "aws-cdk-lib";
 import { BucketDeployment } from "aws-cdk-lib/aws-s3-deployment";
+import { Grant, IGrantable } from "aws-cdk-lib/aws-iam";
 /**
  * Domain name properties for a bucket based website.
  */
@@ -58,4 +59,81 @@ export declare class WebsiteBucket extends Construct {
      * @param prune
      */
     deploy(path: string, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment;
+    /**
+     * Grant read permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If encryption is used, permission to use the key to decrypt the contents
+     * of the bucket will also be granted to the same principal.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantRead(identity: IGrantable, objectsKeyPattern?: any): Grant;
+    /**
+     * Grant write permissions to this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     * @param allowedActionPatterns Restrict the permissions to certain list of action patterns
+     */
+    grantWrite(identity: IGrantable, objectsKeyPattern?: any, allowedActionPatterns?: string[]): Grant;
+    /**
+     * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPut(identity: IGrantable, objectsKeyPattern?: any): Grant;
+    /**
+     * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.
+     *
+     * If your application has the '@aws-cdk/aws-s3:grantWriteWithoutAcl' feature flag set,
+     * calling `grantWrite` or `grantReadWrite` no longer grants permissions to modify the ACLs of the objects;
+     * in this case, if you need to modify object ACLs, call this method explicitly.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPutAcl(identity: IGrantable, objectsKeyPattern?: string): Grant;
+    /**
+     * Grants s3:DeleteObject* permission to an IAM principal for objects
+     * in this bucket.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantDelete(identity: IGrantable, objectsKeyPattern?: any): Grant;
+    /**
+     * Grants read/write permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to use the key for
+     * encrypt/decrypt will also be granted.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantReadWrite(identity: IGrantable, objectsKeyPattern?: any): Grant;
 }

package/aws-s3/lib/website-bucket.js

@@ -73,6 +73,95 @@ class WebsiteBucket extends constructs_1.Construct {
             ]
         });
     }
+    /**
+     * Grant read permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If encryption is used, permission to use the key to decrypt the contents
+     * of the bucket will also be granted to the same principal.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantRead(identity, objectsKeyPattern) {
+        return this.bucket.grantRead(identity, objectsKeyPattern);
+    }
+    /**
+     * Grant write permissions to this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     * @param allowedActionPatterns Restrict the permissions to certain list of action patterns
+     */
+    grantWrite(identity, objectsKeyPattern, allowedActionPatterns) {
+        return this.bucket.grantWrite(identity, objectsKeyPattern, allowedActionPatterns);
+    }
+    /**
+     * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.
+     *
+     * If encryption is used, permission to use the key to encrypt the contents
+     * of written files will also be granted to the same principal.
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPut(identity, objectsKeyPattern) {
+        return this.bucket.grantPut(identity, objectsKeyPattern);
+    }
+    /**
+     * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.
+     *
+     * If your application has the '@aws-cdk/aws-s3:grantWriteWithoutAcl' feature flag set,
+     * calling `grantWrite` or `grantReadWrite` no longer grants permissions to modify the ACLs of the objects;
+     * in this case, if you need to modify object ACLs, call this method explicitly.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantPutAcl(identity, objectsKeyPattern) {
+        return this.bucket.grantPutAcl(identity, objectsKeyPattern);
+    }
+    /**
+     * Grants s3:DeleteObject* permission to an IAM principal for objects
+     * in this bucket.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantDelete(identity, objectsKeyPattern) {
+        return this.bucket.grantDelete(identity, objectsKeyPattern);
+    }
+    /**
+     * Grants read/write permissions for this bucket and it's contents to an IAM
+     * principal (Role/Group/User).
+     *
+     * If an encryption key is used, permission to use the key for
+     * encrypt/decrypt will also be granted.
+     *
+     * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,
+     * which could be used to grant read/write object access to IAM principals in other accounts.
+     * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,
+     * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`
+     * in the `context` key of your cdk.json file.
+     * If you've already updated, but still need the principal to have permissions to modify the ACLs,
+     * use the `grantPutAcl` method.
+     *
+     * @param identity The principal
+     * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')
+     */
+    grantReadWrite(identity, objectsKeyPattern) {
+        return this.bucket.grantReadWrite(identity, objectsKeyPattern);
+    }
 }
 exports.WebsiteBucket = WebsiteBucket;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"website-bucket.js","sourceRoot":"","sources":["website-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from \"constructs\";\nimport {Bucket, BucketEncryption, RedirectTarget, RoutingRule} from \"aws-cdk-lib/aws-s3\";\nimport {DomainName, LatencyARecord, WeightedARecord} from \"../../aws-route53\";\nimport {ARecord, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {BucketWebsiteTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {RemovalPolicy, Duration} from \"aws-cdk-lib\";\nimport {BucketDeployment, CacheControl, Source} from \"aws-cdk-lib/aws-s3-deployment\";\n\n\n/**\n * Domain name properties for a bucket based website.\n */\nexport interface WebsiteDomainNameProps {\n\n  readonly prefix?: string;\n\n  readonly zone: string | IHostedZone;\n\n  readonly weight?: number;\n\n  readonly latency?: boolean;\n\n  readonly create?: boolean;\n\n}\n\n/**\n * Properties for WebsiteBucket.\n */\nexport interface WebsiteBucketProps {\n\n  /**\n   * Policy to apply when the bucket is removed from this stack.\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Whether all objects should be automatically deleted when the bucket is removed from the stack or when the stack is deleted.\n   * Requires the removalPolicy to be set to RemovalPolicy.DESTROY.\n   *\n   * @default false\n   */\n  readonly autoDeleteObjects?: boolean;\n\n  readonly domainName?: WebsiteDomainNameProps;\n\n  readonly websiteIndexDocument?: string;\n\n  readonly websiteErrorDocument?: string;\n\n  readonly websiteRedirect?: RedirectTarget;\n\n  readonly websiteRoutingRules?: RoutingRule[];\n}\n\n/**\n * Simple Construct for creating buckets that will be accessed directly as a website.\n */\nexport class WebsiteBucket extends Construct {\n\n  readonly bucket: Bucket;\n  readonly bucketName: string;\n  readonly bucketArn: string;\n  readonly bucketWebsiteUrl: string;\n  readonly bucketWebsiteDomainName: string;\n  readonly record: ARecord | WeightedARecord | LatencyARecord;\n\n  constructor(scope: Construct, id: string, props?: WebsiteBucketProps) {\n    super(scope, id);\n\n    const removalPolicy = props?.removalPolicy ?? RemovalPolicy.RETAIN;\n    const autoDeleteObjects = (props?.autoDeleteObjects ?? false) && removalPolicy === RemovalPolicy.DESTROY;\n\n    const domainName = props?.domainName === undefined ? undefined : new DomainName({\n      prefix: props.domainName.prefix,\n      zone: props.domainName.zone\n    });\n\n    this.bucket = new Bucket(this, \"Default\", {\n      bucketName: domainName?.toString(),\n      encryption: BucketEncryption.S3_MANAGED,\n      publicReadAccess: true,\n      websiteIndexDocument: props?.websiteIndexDocument ?? \"index.html\",\n      websiteErrorDocument: props?.websiteErrorDocument ?? \"error.html\",\n      websiteRedirect: props?.websiteRedirect,\n      websiteRoutingRules: props?.websiteRoutingRules,\n      removalPolicy,\n      autoDeleteObjects,\n    });\n    this.bucketName = this.bucket.bucketName;\n    this.bucketArn = this.bucket.bucketArn;\n    this.bucketWebsiteUrl = this.bucket.bucketWebsiteUrl;\n    this.bucketWebsiteDomainName = this.bucket.bucketWebsiteDomainName;\n\n    if (domainName !== undefined && (props?.domainName?.create ?? true)) {\n      const target = RecordTarget.fromAlias(new BucketWebsiteTarget(this.bucket));\n      // TODO Evaluate\n      if (props?.domainName?.latency !== undefined) {\n        this.record = domainName.createLatencyARecord(this, target);\n      } else if (props?.domainName?.weight !== undefined) {\n        this.record = domainName.createWeightedARecord(this, target, props.domainName.weight);\n      } else {\n        this.record = domainName.createARecord(this, target);\n      }\n    }\n  }\n\n  /**\n   * Helper method to deploy local assets to the created bucket. Ths function assumes\n   * CloudFront invalidation requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param path the path to the local assets\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune\n   */\n  deploy(path: string, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return new BucketDeployment(this, \"Deploy\", {\n      sources: [Source.asset(path)],\n      destinationBucket: this.bucket,\n      prune: prune ?? false,\n      memoryLimit: 512,\n      cacheControl: [\n        CacheControl.setPublic(),\n        CacheControl.maxAge(maxAge ?? Duration.minutes(15)),\n        CacheControl.sMaxAge(sMaxAge ?? Duration.days(7))\n      ]\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"website-bucket.js","sourceRoot":"","sources":["website-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from \"constructs\";\nimport {Bucket, BucketEncryption, RedirectTarget, RoutingRule} from \"aws-cdk-lib/aws-s3\";\nimport {DomainName, LatencyARecord, WeightedARecord} from \"../../aws-route53\";\nimport {ARecord, IHostedZone, RecordTarget} from \"aws-cdk-lib/aws-route53\";\nimport {BucketWebsiteTarget} from \"aws-cdk-lib/aws-route53-targets\";\nimport {RemovalPolicy, Duration} from \"aws-cdk-lib\";\nimport {BucketDeployment, CacheControl, Source} from \"aws-cdk-lib/aws-s3-deployment\";\nimport {Grant, IGrantable} from \"aws-cdk-lib/aws-iam\";\n\n\n/**\n * Domain name properties for a bucket based website.\n */\nexport interface WebsiteDomainNameProps {\n\n  readonly prefix?: string;\n\n  readonly zone: string | IHostedZone;\n\n  readonly weight?: number;\n\n  readonly latency?: boolean;\n\n  readonly create?: boolean;\n\n}\n\n/**\n * Properties for WebsiteBucket.\n */\nexport interface WebsiteBucketProps {\n\n  /**\n   * Policy to apply when the bucket is removed from this stack.\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Whether all objects should be automatically deleted when the bucket is removed from the stack or when the stack is deleted.\n   * Requires the removalPolicy to be set to RemovalPolicy.DESTROY.\n   *\n   * @default false\n   */\n  readonly autoDeleteObjects?: boolean;\n\n  readonly domainName?: WebsiteDomainNameProps;\n\n  readonly websiteIndexDocument?: string;\n\n  readonly websiteErrorDocument?: string;\n\n  readonly websiteRedirect?: RedirectTarget;\n\n  readonly websiteRoutingRules?: RoutingRule[];\n}\n\n/**\n * Simple Construct for creating buckets that will be accessed directly as a website.\n */\nexport class WebsiteBucket extends Construct {\n\n  readonly bucket: Bucket;\n  readonly bucketName: string;\n  readonly bucketArn: string;\n  readonly bucketWebsiteUrl: string;\n  readonly bucketWebsiteDomainName: string;\n  readonly record: ARecord | WeightedARecord | LatencyARecord;\n\n  constructor(scope: Construct, id: string, props?: WebsiteBucketProps) {\n    super(scope, id);\n\n    const removalPolicy = props?.removalPolicy ?? RemovalPolicy.RETAIN;\n    const autoDeleteObjects = (props?.autoDeleteObjects ?? false) && removalPolicy === RemovalPolicy.DESTROY;\n\n    const domainName = props?.domainName === undefined ? undefined : new DomainName({\n      prefix: props.domainName.prefix,\n      zone: props.domainName.zone\n    });\n\n    this.bucket = new Bucket(this, \"Default\", {\n      bucketName: domainName?.toString(),\n      encryption: BucketEncryption.S3_MANAGED,\n      publicReadAccess: true,\n      websiteIndexDocument: props?.websiteIndexDocument ?? \"index.html\",\n      websiteErrorDocument: props?.websiteErrorDocument ?? \"error.html\",\n      websiteRedirect: props?.websiteRedirect,\n      websiteRoutingRules: props?.websiteRoutingRules,\n      removalPolicy,\n      autoDeleteObjects,\n    });\n    this.bucketName = this.bucket.bucketName;\n    this.bucketArn = this.bucket.bucketArn;\n    this.bucketWebsiteUrl = this.bucket.bucketWebsiteUrl;\n    this.bucketWebsiteDomainName = this.bucket.bucketWebsiteDomainName;\n\n    if (domainName !== undefined && (props?.domainName?.create ?? true)) {\n      const target = RecordTarget.fromAlias(new BucketWebsiteTarget(this.bucket));\n      // TODO Evaluate\n      if (props?.domainName?.latency !== undefined) {\n        this.record = domainName.createLatencyARecord(this, target);\n      } else if (props?.domainName?.weight !== undefined) {\n        this.record = domainName.createWeightedARecord(this, target, props.domainName.weight);\n      } else {\n        this.record = domainName.createARecord(this, target);\n      }\n    }\n  }\n\n  /**\n   * Helper method to deploy local assets to the created bucket. Ths function assumes\n   * CloudFront invalidation requests will be sent for mutable files to serve new content.\n   * For more complicated deployments, use BucketDeployment directly.\n   *\n   * @param path the path to the local assets\n   * @param maxAge the length of time to browsers will cache files; default is Duration.minutes(15)\n   * @param sMaxAge the length of time CloudFront will cache files; default is Duration.days(7)\n   * @param prune\n   */\n  deploy(path: string, maxAge?: Duration, sMaxAge?: Duration, prune?: boolean): BucketDeployment {\n    return new BucketDeployment(this, \"Deploy\", {\n      sources: [Source.asset(path)],\n      destinationBucket: this.bucket,\n      prune: prune ?? false,\n      memoryLimit: 512,\n      cacheControl: [\n        CacheControl.setPublic(),\n        CacheControl.maxAge(maxAge ?? Duration.minutes(15)),\n        CacheControl.sMaxAge(sMaxAge ?? Duration.days(7))\n      ]\n    });\n  }\n\n  /**\n   * Grant read permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If encryption is used, permission to use the key to decrypt the contents\n   * of the bucket will also be granted to the same principal.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantRead(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantRead(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grant write permissions to this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   *\n   * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,\n   * which could be used to grant read/write object access to IAM principals in other accounts.\n   * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,\n   * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`\n   * in the `context` key of your cdk.json file.\n   * If you've already updated, but still need the principal to have permissions to modify the ACLs,\n   * use the `grantPutAcl` method.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   * @param allowedActionPatterns Restrict the permissions to certain list of action patterns\n   */\n  grantWrite(identity: IGrantable, objectsKeyPattern?: any, allowedActionPatterns?: string[]): Grant {\n    return this.bucket.grantWrite(identity, objectsKeyPattern, allowedActionPatterns);\n  }\n\n  /**\n   * Grants s3:PutObject* and s3:Abort* permissions for this bucket to an IAM principal.\n   *\n   * If encryption is used, permission to use the key to encrypt the contents\n   * of written files will also be granted to the same principal.\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantPut(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantPut(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grant the given IAM identity permissions to modify the ACLs of objects in the given Bucket.\n   *\n   * If your application has the '@aws-cdk/aws-s3:grantWriteWithoutAcl' feature flag set,\n   * calling `grantWrite` or `grantReadWrite` no longer grants permissions to modify the ACLs of the objects;\n   * in this case, if you need to modify object ACLs, call this method explicitly.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantPutAcl(identity: IGrantable, objectsKeyPattern?: string): Grant {\n    return this.bucket.grantPutAcl(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grants s3:DeleteObject* permission to an IAM principal for objects\n   * in this bucket.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantDelete(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantDelete(identity, objectsKeyPattern);\n  }\n\n  /**\n   * Grants read/write permissions for this bucket and it's contents to an IAM\n   * principal (Role/Group/User).\n   *\n   * If an encryption key is used, permission to use the key for\n   * encrypt/decrypt will also be granted.\n   *\n   * Before CDK version 1.85.0, this method granted the `s3:PutObject*` permission that included `s3:PutObjectAcl`,\n   * which could be used to grant read/write object access to IAM principals in other accounts.\n   * If you want to get rid of that behavior, update your CDK version to 1.85.0 or later,\n   * and make sure the `@aws-cdk/aws-s3:grantWriteWithoutAcl` feature flag is set to `true`\n   * in the `context` key of your cdk.json file.\n   * If you've already updated, but still need the principal to have permissions to modify the ACLs,\n   * use the `grantPutAcl` method.\n   *\n   * @param identity The principal\n   * @param objectsKeyPattern Restrict the permission to a certain key pattern (default '*')\n   */\n  grantReadWrite(identity: IGrantable, objectsKeyPattern?: any): Grant {\n    return this.bucket.grantReadWrite(identity, objectsKeyPattern);\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "truemark-cdk-lib",
-  "version": "1.6.5",
+  "version": "1.6.6",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
@@ -72,5 +72,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8b125ab93367f1da7193bddfb93096d10b583a86"
+  "gitHead": "cfd8ebcfcea1904a6b70a7b5590c9991e5a8ad24"
 }