@aws-cdk/aws-s3tables-alpha 2.190.0-alpha.0

package/lib/table-bucket.d.ts

@@ -0,0 +1,287 @@
+import { Construct } from 'constructs';
+import { TableBucketPolicy } from './table-bucket-policy';
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { Resource, IResource, RemovalPolicy } from 'aws-cdk-lib/core';
+/**
+ * Interface definition for S3 Table Buckets
+ */
+export interface ITableBucket extends IResource {
+    /**
+     * The ARN of the table bucket.
+     * @attribute
+     */
+    readonly tableBucketArn: string;
+    /**
+     * The name of the table bucket.
+     * @attribute
+     */
+    readonly tableBucketName: string;
+    /**
+     * The accountId containing the table bucket.
+     * @attribute
+     */
+    readonly account?: string;
+    /**
+     * The region containing the table bucket.
+     * @attribute
+     */
+    readonly region?: string;
+    /**
+     * Adds a statement to the resource policy for a principal (i.e.
+     * account/role/service) to perform actions on this table bucket and/or its
+     * contents. Use `tableBucketArn` and `arnForObjects(keys)` to obtain ARNs for
+     * this bucket or objects.
+     *
+     * Note that the policy statement may or may not be added to the policy.
+     * For example, when an `ITableBucket` is created from an existing table bucket,
+     * it's not possible to tell whether the bucket already has a policy
+     * attached, let alone to re-use that policy to add more statements to it.
+     * So it's safest to do nothing in these cases.
+     *
+     * @param statement the policy statement to be added to the bucket's
+     * policy.
+     * @returns metadata about the execution of this method. If the policy
+     * was not added, the value of `statementAdded` will be `false`. You
+     * should always check this value to make sure that the operation was
+     * actually carried out. Otherwise, synthesis and deploy will terminate
+     * silently, which may be confusing.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    /**
+     * Grant read permissions for this table bucket and its tables
+     * to an IAM principal (Role/Group/User).
+     *
+     * @param identity The principal to allow read permissions to
+     * @param tableId Allow the permissions to all tables using '*' or to single table by its unique ID.
+     */
+    grantRead(identity: iam.IGrantable, tableId: string): iam.Grant;
+    /**
+     * Grant write permissions for this table bucket and its tables
+     * to an IAM principal (Role/Group/User).
+     *
+     * @param identity The principal to allow write permissions to
+     * @param tableId Allow the permissions to all tables using '*' or to single table by its unique ID.
+     */
+    grantWrite(identity: iam.IGrantable, tableId: string): iam.Grant;
+    /**
+     * Grant read and write permissions for this table bucket and its tables
+     * to an IAM principal (Role/Group/User).
+     *
+     * @param identity The principal to allow read and write permissions to
+     * @param tableId Allow the permissions to all tables using '*' or to single table by its unique ID.
+     */
+    grantReadWrite(identity: iam.IGrantable, tableId: string): iam.Grant;
+}
+/**
+ * Unreferenced file removal settings for the this table bucket.
+ */
+export interface UnreferencedFileRemoval {
+    /**
+     * Duration after which noncurrent files should be removed. Should be at least one day.
+     * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html
+     *
+     * @default - See S3 Tables User Guide
+     */
+    readonly noncurrentDays?: number;
+    /**
+     * Status of unreferenced file removal. Can be Enabled or Disabled.
+     * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html
+     *
+     * @default - See S3 Tables User Guide
+     */
+    readonly status?: UnreferencedFileRemovalStatus;
+    /**
+     * Duration after which unreferenced files should be removed. Should be at least one day.
+     * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html
+     *
+     * @default - See S3 Tables User Guide
+     */
+    readonly unreferencedDays?: number;
+}
+/**
+ * Controls whether unreferenced file removal is enabled or disabled.
+ */
+export declare enum UnreferencedFileRemovalStatus {
+    /**
+     * Enable unreferenced file removal.
+     */
+    ENABLED = "Enabled",
+    /**
+     * Disable unreferenced file removal.
+     */
+    DISABLED = "Disabled"
+}
+declare abstract class TableBucketBase extends Resource implements ITableBucket {
+    abstract readonly tableBucketArn: string;
+    abstract readonly tableBucketName: string;
+    /**
+     * The resource policy associated with this table bucket.
+     *
+     * If `autoCreatePolicy` is true, a `TableBucketPolicy` will be created upon the
+     * first call to addToResourcePolicy(s).
+     */
+    abstract tableBucketPolicy?: TableBucketPolicy;
+    /**
+     * Indicates if a table bucket resource policy should automatically created upon
+     * the first call to `addToResourcePolicy`.
+     */
+    protected abstract autoCreatePolicy: boolean;
+    /**
+     * Adds a statement to the resource policy for a principal (i.e.
+     * account/role/service) to perform actions on this table bucket and/or its
+     * contents. Use `tableBucketArn` and `arnForObjects(keys)` to obtain ARNs for
+     * this bucket or objects.
+     *
+     * Note that the policy statement may or may not be added to the policy.
+     * For example, when an `ITableBucket` is created from an existing table bucket,
+     * it's not possible to tell whether the bucket already has a policy
+     * attached, let alone to re-use that policy to add more statements to it.
+     * So it's safest to do nothing in these cases.
+     *
+     * @param statement the policy statement to be added to the bucket's
+     * policy.
+     * @returns metadata about the execution of this method. If the policy
+     * was not added, the value of `statementAdded` will be `false`. You
+     * should always check this value to make sure that the operation was
+     * actually carried out. Otherwise, synthesis and deploy will terminate
+     * silently, which may be confusing.
+     */
+    addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    grantRead(identity: iam.IGrantable, tableId: string): iam.Grant;
+    grantWrite(identity: iam.IGrantable, tableId: string): iam.Grant;
+    grantReadWrite(identity: iam.IGrantable, tableId: string): iam.Grant;
+    /**
+     * Grants the given s3tables permissions to the provided principal
+     * @returns Grant object
+     */
+    private grant;
+    private getTableArn;
+}
+/**
+ * Parameters for constructing a TableBucket
+ */
+export interface TableBucketProps {
+    /**
+     * Name of the S3 TableBucket.
+     * @link https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-naming.html#table-buckets-naming-rules
+     */
+    readonly tableBucketName: string;
+    /**
+     * Unreferenced file removal settings for the S3 TableBucket.
+     * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3tables-tablebucket-unreferencedfileremoval.html
+     * @default Enabled with default values
+     * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html
+     */
+    readonly unreferencedFileRemoval?: UnreferencedFileRemoval;
+    /**
+     * AWS region that the table bucket exists in.
+     *
+     * @default - it's assumed the bucket is in the same region as the scope it's being imported into
+     */
+    readonly region?: string;
+    /**
+     * AWS Account ID of the table bucket owner.
+     *
+     * @default - it's assumed the bucket belongs to the same account as the scope it's being imported into
+     */
+    readonly account?: string;
+    /**
+     * Controls what happens to this table bucket it it stoped being managed by cloudformation.
+     *
+     * @default RETAIN
+     */
+    readonly removalPolicy?: RemovalPolicy;
+}
+/**
+ * Everything needed to reference a specific table bucket.
+ * The tableBucketName, region, and account can be provided explicitly
+ * or will be inferred from the tableBucketArn
+ */
+export interface TableBucketAttributes {
+    /**
+     * AWS region this table bucket exists in
+     * @default region inferred from scope
+     */
+    readonly region?: string;
+    /**
+     * The accountId containing this table bucket
+     * @default account inferred from scope
+     */
+    readonly account?: string;
+    /**
+     * The table bucket name, unique per region
+     * @default tableBucketName inferred from arn
+     */
+    readonly tableBucketName?: string;
+    /**
+     * The table bucket's ARN.
+     * @default tableBucketArn constructed from region, account and tableBucketName are provided
+     */
+    readonly tableBucketArn?: string;
+}
+/**
+ * An S3 table bucket with helpers for associated resource policies
+ *
+ * This bucket may not yet have all features that exposed by the underlying CfnTableBucket.
+ *
+ * @stateful
+ * @example
+ * const sampleTableBucket = new TableBucket(scope, 'ExampleTableBucket', {
+ *   tableBucketName: 'example-bucket',
+ *   // Optional fields:
+ *   unreferencedFileRemoval: {
+ *     noncurrentDays: 123,
+ *     status: UnreferencedFileRemovalStatus.ENABLED,
+ *     unreferencedDays: 123,
+ *   },
+ * });
+ */
+export declare class TableBucket extends TableBucketBase {
+    /**
+     * Defines a TableBucket construct from an external table bucket ARN.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param tableBucketArn Amazon Resource Name (arn) of the table bucket
+     */
+    static fromTableBucketArn(scope: Construct, id: string, tableBucketArn: string): ITableBucket;
+    /**
+     * Defines a TableBucket construct that represents an external table bucket.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param attrs A `TableBucketAttributes` object. Can be manually created.
+     */
+    static fromTableBucketAttributes(scope: Construct, id: string, attrs: TableBucketAttributes): ITableBucket;
+    /**
+     * Throws an exception if the given table bucket name is not valid.
+     *
+     * @param bucketName name of the bucket.
+     */
+    static validateTableBucketName(bucketName: string | undefined): void;
+    /**
+     * Throws an exception if the given unreferencedFileRemovalProperty is not valid.
+     * @param unreferencedFileRemoval configuration for the table bucket
+     */
+    static validateUnreferencedFileRemoval(unreferencedFileRemoval?: UnreferencedFileRemoval): void;
+    /**
+     * The underlying CfnTableBucket L1 resource
+     * @internal
+     */
+    private readonly _resource;
+    /**
+     * The resource policy for this tableBucket.
+     */
+    readonly tableBucketPolicy?: TableBucketPolicy;
+    /**
+     * The unique Amazon Resource Name (arn) of this table bucket
+     */
+    readonly tableBucketArn: string;
+    /**
+     * The name of this table bucket
+     */
+    readonly tableBucketName: string;
+    protected autoCreatePolicy: boolean;
+    constructor(scope: Construct, id: string, props: TableBucketProps);
+}
+export {};

package/lib/table-bucket.js

@@ -0,0 +1,269 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableBucket = exports.UnreferencedFileRemovalStatus = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const os_1 = require("os");
+const s3tables = require("aws-cdk-lib/aws-s3tables");
+const table_bucket_policy_1 = require("./table-bucket-policy");
+const perms = require("./permissions");
+const util_1 = require("./util");
+const iam = require("aws-cdk-lib/aws-iam");
+const core_1 = require("aws-cdk-lib/core");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+/**
+ * Controls whether unreferenced file removal is enabled or disabled.
+ */
+var UnreferencedFileRemovalStatus;
+(function (UnreferencedFileRemovalStatus) {
+    /**
+     * Enable unreferenced file removal.
+     */
+    UnreferencedFileRemovalStatus["ENABLED"] = "Enabled";
+    /**
+     * Disable unreferenced file removal.
+     */
+    UnreferencedFileRemovalStatus["DISABLED"] = "Disabled";
+})(UnreferencedFileRemovalStatus || (exports.UnreferencedFileRemovalStatus = UnreferencedFileRemovalStatus = {}));
+class TableBucketBase extends core_1.Resource {
+    /**
+     * Adds a statement to the resource policy for a principal (i.e.
+     * account/role/service) to perform actions on this table bucket and/or its
+     * contents. Use `tableBucketArn` and `arnForObjects(keys)` to obtain ARNs for
+     * this bucket or objects.
+     *
+     * Note that the policy statement may or may not be added to the policy.
+     * For example, when an `ITableBucket` is created from an existing table bucket,
+     * it's not possible to tell whether the bucket already has a policy
+     * attached, let alone to re-use that policy to add more statements to it.
+     * So it's safest to do nothing in these cases.
+     *
+     * @param statement the policy statement to be added to the bucket's
+     * policy.
+     * @returns metadata about the execution of this method. If the policy
+     * was not added, the value of `statementAdded` will be `false`. You
+     * should always check this value to make sure that the operation was
+     * actually carried out. Otherwise, synthesis and deploy will terminate
+     * silently, which may be confusing.
+     */
+    addToResourcePolicy(statement) {
+        if (!this.tableBucketPolicy && this.autoCreatePolicy) {
+            this.tableBucketPolicy = new table_bucket_policy_1.TableBucketPolicy(this, 'DefaultPolicy', {
+                tableBucket: this,
+            });
+        }
+        if (this.tableBucketPolicy) {
+            this.tableBucketPolicy.document.addStatements(statement);
+            return { statementAdded: true, policyDependable: this.tableBucketPolicy };
+        }
+        return { statementAdded: false };
+    }
+    grantRead(identity, tableId) {
+        return this.grant(identity, perms.TABLE_BUCKET_READ_ACCESS, this.tableBucketArn, this.getTableArn(tableId));
+    }
+    grantWrite(identity, tableId) {
+        return this.grant(identity, perms.TABLE_BUCKET_WRITE_ACCESS, this.tableBucketArn, this.getTableArn(tableId));
+    }
+    grantReadWrite(identity, tableId) {
+        return this.grant(identity, perms.TABLE_BUCKET_READ_WRITE_ACCESS, this.tableBucketArn, this.getTableArn(tableId));
+    }
+    /**
+     * Grants the given s3tables permissions to the provided principal
+     * @returns Grant object
+     */
+    grant(grantee, tableBucketActions, resourceArn, ...otherResourceArns) {
+        const resources = [resourceArn, ...otherResourceArns].filter(arn => arn != undefined);
+        return iam.Grant.addToPrincipalOrResource({
+            grantee,
+            actions: tableBucketActions,
+            resourceArns: resources,
+            resource: this,
+        });
+    }
+    getTableArn(tableId) {
+        return tableId ? `${this.tableBucketArn}/table/${tableId}` : undefined;
+    }
+}
+/**
+ * An S3 table bucket with helpers for associated resource policies
+ *
+ * This bucket may not yet have all features that exposed by the underlying CfnTableBucket.
+ *
+ * @stateful
+ * @example
+ * const sampleTableBucket = new TableBucket(scope, 'ExampleTableBucket', {
+ *   tableBucketName: 'example-bucket',
+ *   // Optional fields:
+ *   unreferencedFileRemoval: {
+ *     noncurrentDays: 123,
+ *     status: UnreferencedFileRemovalStatus.ENABLED,
+ *     unreferencedDays: 123,
+ *   },
+ * });
+ */
+class TableBucket extends TableBucketBase {
+    /**
+     * Defines a TableBucket construct from an external table bucket ARN.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param tableBucketArn Amazon Resource Name (arn) of the table bucket
+     */
+    static fromTableBucketArn(scope, id, tableBucketArn) {
+        return TableBucket.fromTableBucketAttributes(scope, id, { tableBucketArn });
+    }
+    /**
+     * Defines a TableBucket construct that represents an external table bucket.
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param attrs A `TableBucketAttributes` object. Can be manually created.
+     */
+    static fromTableBucketAttributes(scope, id, attrs) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_s3tables_alpha_TableBucketAttributes(attrs);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.fromTableBucketAttributes);
+            }
+            throw error;
+        }
+        const { tableBucketName, region, account, tableBucketArn } = (0, util_1.validateTableBucketAttributes)(scope, attrs);
+        TableBucket.validateTableBucketName(tableBucketName);
+        class Import extends TableBucketBase {
+            constructor() {
+                super(...arguments);
+                this.tableBucketName = tableBucketName;
+                this.tableBucketArn = tableBucketArn;
+                this.region = region;
+                this.account = account;
+                this.autoCreatePolicy = false;
+            }
+            /**
+             * Exports this bucket from the stack.
+             */
+            export() {
+                return attrs;
+            }
+        }
+        return new Import(scope, id, {
+            account,
+            region,
+            physicalName: tableBucketName,
+        });
+    }
+    /**
+     * Throws an exception if the given table bucket name is not valid.
+     *
+     * @param bucketName name of the bucket.
+     */
+    static validateTableBucketName(bucketName) {
+        if (bucketName == undefined || core_1.Token.isUnresolved(bucketName)) {
+            // the name is a late-bound value, not a defined string, so skip validation
+            return;
+        }
+        const errors = [];
+        // Length validation
+        if (bucketName.length < 3 || bucketName.length > 63) {
+            errors.push('Bucket name must be at least 3 and no more than 63 characters');
+        }
+        // Character set validation
+        const illegalCharsetRegEx = /[^a-z0-9-]/;
+        const allowedEdgeCharsetRegEx = /[a-z0-9]/;
+        const illegalCharMatch = bucketName.match(illegalCharsetRegEx);
+        if (illegalCharMatch) {
+            errors.push('Bucket name must only contain lowercase characters, numbers, and hyphens (-)' +
+                ` (offset: ${illegalCharMatch.index})`);
+        }
+        // Edge character validation
+        if (!allowedEdgeCharsetRegEx.test(bucketName.charAt(0))) {
+            errors.push('Bucket name must start with a lowercase letter or number (offset: 0)');
+        }
+        if (!allowedEdgeCharsetRegEx.test(bucketName.charAt(bucketName.length - 1))) {
+            errors.push(`Bucket name must end with a lowercase letter or number (offset: ${bucketName.length - 1})`);
+        }
+        if (errors.length > 0) {
+            throw new core_1.UnscopedValidationError(`Invalid S3 table bucket name (value: ${bucketName})${os_1.EOL}${errors.join(os_1.EOL)}`);
+        }
+    }
+    /**
+     * Throws an exception if the given unreferencedFileRemovalProperty is not valid.
+     * @param unreferencedFileRemoval configuration for the table bucket
+     */
+    static validateUnreferencedFileRemoval(unreferencedFileRemoval) {
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_s3tables_alpha_UnreferencedFileRemoval(unreferencedFileRemoval);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, this.validateUnreferencedFileRemoval);
+            }
+            throw error;
+        }
+        // Skip validation if property is not defined
+        if (!unreferencedFileRemoval) {
+            return;
+        }
+        const { noncurrentDays, status, unreferencedDays } = unreferencedFileRemoval;
+        const errors = [];
+        if (noncurrentDays != undefined) {
+            if (noncurrentDays < 1) {
+                errors.push('noncurrentDays must be at least 1 day');
+            }
+            if (!Number.isInteger(noncurrentDays)) {
+                errors.push('noncurrentDays must be a whole number');
+            }
+        }
+        if (unreferencedDays != undefined) {
+            if (unreferencedDays < 1) {
+                errors.push('unreferencedDays must be at least 1 day');
+            }
+            if (!Number.isInteger(noncurrentDays)) {
+                errors.push('unreferencedDays must be a whole number');
+            }
+        }
+        const allowedStatus = ['Enabled', 'Disabled'];
+        if (status != undefined && !allowedStatus.includes(status)) {
+            errors.push('status must be one of \'Enabled\' or \'Disabled\'');
+        }
+        if (errors.length > 0) {
+            throw new core_1.UnscopedValidationError(`Invalid UnreferencedFileRemovalProperty})${os_1.EOL}${errors.join(os_1.EOL)}`);
+        }
+    }
+    constructor(scope, id, props) {
+        super(scope, id, {
+            physicalName: props.tableBucketName,
+        });
+        this.autoCreatePolicy = true;
+        try {
+            jsiiDeprecationWarnings._aws_cdk_aws_s3tables_alpha_TableBucketProps(props);
+        }
+        catch (error) {
+            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                Error.captureStackTrace(error, TableBucket);
+            }
+            throw error;
+        }
+        // Enhanced CDK Analytics Telemetry
+        (0, metadata_resource_1.addConstructMetadata)(this, props);
+        TableBucket.validateTableBucketName(props.tableBucketName);
+        TableBucket.validateUnreferencedFileRemoval(props.unreferencedFileRemoval);
+        this._resource = new s3tables.CfnTableBucket(this, id, {
+            tableBucketName: props.tableBucketName,
+            unreferencedFileRemoval: {
+                ...props.unreferencedFileRemoval,
+                noncurrentDays: props.unreferencedFileRemoval?.noncurrentDays,
+                unreferencedDays: props.unreferencedFileRemoval?.unreferencedDays,
+            },
+        });
+        this.tableBucketName = this.getResourceNameAttribute(this._resource.ref);
+        this.tableBucketArn = this._resource.attrTableBucketArn;
+        this._resource.applyRemovalPolicy(props.removalPolicy);
+    }
+}
+exports.TableBucket = TableBucket;
+_a = JSII_RTTI_SYMBOL_1;
+TableBucket[_a] = { fqn: "@aws-cdk/aws-s3tables-alpha.TableBucket", version: "2.190.0-alpha.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-bucket.js","sourceRoot":"","sources":["table-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import { EOL } from 'os';\nimport { Construct } from 'constructs';\nimport * as s3tables from 'aws-cdk-lib/aws-s3tables';\nimport { TableBucketPolicy } from './table-bucket-policy';\nimport * as perms from './permissions';\nimport { validateTableBucketAttributes } from './util';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Resource, IResource, UnscopedValidationError, RemovalPolicy, Token } from 'aws-cdk-lib/core';\nimport { addConstructMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\n\n/**\n * Interface definition for S3 Table Buckets\n */\nexport interface ITableBucket extends IResource {\n  /**\n   * The ARN of the table bucket.\n   * @attribute\n   */\n  readonly tableBucketArn: string;\n\n  /**\n   * The name of the table bucket.\n   * @attribute\n   */\n  readonly tableBucketName: string;\n\n  /**\n   * The accountId containing the table bucket.\n   * @attribute\n   */\n  readonly account?: string;\n\n  /**\n   * The region containing the table bucket.\n   * @attribute\n   */\n  readonly region?: string;\n\n  /**\n   * Adds a statement to the resource policy for a principal (i.e.\n   * account/role/service) to perform actions on this table bucket and/or its\n   * contents. Use `tableBucketArn` and `arnForObjects(keys)` to obtain ARNs for\n   * this bucket or objects.\n   *\n   * Note that the policy statement may or may not be added to the policy.\n   * For example, when an `ITableBucket` is created from an existing table bucket,\n   * it's not possible to tell whether the bucket already has a policy\n   * attached, let alone to re-use that policy to add more statements to it.\n   * So it's safest to do nothing in these cases.\n   *\n   * @param statement the policy statement to be added to the bucket's\n   * policy.\n   * @returns metadata about the execution of this method. If the policy\n   * was not added, the value of `statementAdded` will be `false`. You\n   * should always check this value to make sure that the operation was\n   * actually carried out. Otherwise, synthesis and deploy will terminate\n   * silently, which may be confusing.\n   */\n  addToResourcePolicy(statement: iam.PolicyStatement): iam.AddToResourcePolicyResult;\n\n  /**\n   * Grant read permissions for this table bucket and its tables\n   * to an IAM principal (Role/Group/User).\n   *\n   * @param identity The principal to allow read permissions to\n   * @param tableId Allow the permissions to all tables using '*' or to single table by its unique ID.\n   */\n  grantRead(identity: iam.IGrantable, tableId: string): iam.Grant;\n\n  /**\n   * Grant write permissions for this table bucket and its tables\n   * to an IAM principal (Role/Group/User).\n   *\n   * @param identity The principal to allow write permissions to\n   * @param tableId Allow the permissions to all tables using '*' or to single table by its unique ID.\n   */\n  grantWrite(identity: iam.IGrantable, tableId: string): iam.Grant;\n\n  /**\n   * Grant read and write permissions for this table bucket and its tables\n   * to an IAM principal (Role/Group/User).\n   *\n   * @param identity The principal to allow read and write permissions to\n   * @param tableId Allow the permissions to all tables using '*' or to single table by its unique ID.\n   */\n  grantReadWrite(identity: iam.IGrantable, tableId: string): iam.Grant;\n}\n\n/**\n * Unreferenced file removal settings for the this table bucket.\n */\nexport interface UnreferencedFileRemoval {\n  /**\n   * Duration after which noncurrent files should be removed. Should be at least one day.\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html\n   *\n   * @default - See S3 Tables User Guide\n   */\n  readonly noncurrentDays?: number;\n\n  /**\n   * Status of unreferenced file removal. Can be Enabled or Disabled.\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html\n   *\n   * @default - See S3 Tables User Guide\n   */\n  readonly status?: UnreferencedFileRemovalStatus;\n\n  /**\n   * Duration after which unreferenced files should be removed. Should be at least one day.\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html\n   *\n   * @default - See S3 Tables User Guide\n   */\n  readonly unreferencedDays?: number;\n}\n\n/**\n * Controls whether unreferenced file removal is enabled or disabled.\n */\nexport enum UnreferencedFileRemovalStatus {\n  /**\n   * Enable unreferenced file removal.\n   */\n  ENABLED = 'Enabled',\n\n  /**\n   * Disable unreferenced file removal.\n   */\n  DISABLED = 'Disabled',\n}\n\nabstract class TableBucketBase extends Resource implements ITableBucket {\n  public abstract readonly tableBucketArn: string;\n  public abstract readonly tableBucketName: string;\n\n  /**\n   * The resource policy associated with this table bucket.\n   *\n   * If `autoCreatePolicy` is true, a `TableBucketPolicy` will be created upon the\n   * first call to addToResourcePolicy(s).\n   */\n  public abstract tableBucketPolicy?: TableBucketPolicy;\n\n  /**\n   * Indicates if a table bucket resource policy should automatically created upon\n   * the first call to `addToResourcePolicy`.\n   */\n  protected abstract autoCreatePolicy: boolean;\n\n  /**\n   * Adds a statement to the resource policy for a principal (i.e.\n   * account/role/service) to perform actions on this table bucket and/or its\n   * contents. Use `tableBucketArn` and `arnForObjects(keys)` to obtain ARNs for\n   * this bucket or objects.\n   *\n   * Note that the policy statement may or may not be added to the policy.\n   * For example, when an `ITableBucket` is created from an existing table bucket,\n   * it's not possible to tell whether the bucket already has a policy\n   * attached, let alone to re-use that policy to add more statements to it.\n   * So it's safest to do nothing in these cases.\n   *\n   * @param statement the policy statement to be added to the bucket's\n   * policy.\n   * @returns metadata about the execution of this method. If the policy\n   * was not added, the value of `statementAdded` will be `false`. You\n   * should always check this value to make sure that the operation was\n   * actually carried out. Otherwise, synthesis and deploy will terminate\n   * silently, which may be confusing.\n   */\n  public addToResourcePolicy(\n    statement: iam.PolicyStatement,\n  ): iam.AddToResourcePolicyResult {\n    if (!this.tableBucketPolicy && this.autoCreatePolicy) {\n      this.tableBucketPolicy = new TableBucketPolicy(this, 'DefaultPolicy', {\n        tableBucket: this,\n      });\n    }\n\n    if (this.tableBucketPolicy) {\n      this.tableBucketPolicy.document.addStatements(statement);\n      return { statementAdded: true, policyDependable: this.tableBucketPolicy };\n    }\n\n    return { statementAdded: false };\n  }\n\n  public grantRead(identity: iam.IGrantable, tableId: string) {\n    return this.grant(identity, perms.TABLE_BUCKET_READ_ACCESS, this.tableBucketArn, this.getTableArn(tableId));\n  }\n\n  public grantWrite(identity: iam.IGrantable, tableId: string) {\n    return this.grant(identity, perms.TABLE_BUCKET_WRITE_ACCESS, this.tableBucketArn, this.getTableArn(tableId));\n  }\n\n  public grantReadWrite(identity: iam.IGrantable, tableId: string) {\n    return this.grant(identity, perms.TABLE_BUCKET_READ_WRITE_ACCESS, this.tableBucketArn, this.getTableArn(tableId));\n  }\n\n  /**\n   * Grants the given s3tables permissions to the provided principal\n   * @returns Grant object\n   */\n  private grant(\n    grantee: iam.IGrantable,\n    tableBucketActions: string[],\n    resourceArn: string,\n    ...otherResourceArns: (string | undefined)[]) {\n    const resources = [resourceArn, ...otherResourceArns].filter(arn => arn != undefined);\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: tableBucketActions,\n      resourceArns: resources,\n      resource: this,\n    });\n  }\n\n  private getTableArn(tableId: string | undefined) {\n    return tableId ? `${this.tableBucketArn}/table/${tableId}` : undefined;\n  }\n}\n\n/**\n * Parameters for constructing a TableBucket\n */\nexport interface TableBucketProps {\n  /**\n   * Name of the S3 TableBucket.\n   * @link https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-tables-buckets-naming.html#table-buckets-naming-rules\n   */\n  readonly tableBucketName: string;\n\n  /**\n   * Unreferenced file removal settings for the S3 TableBucket.\n   * @link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3tables-tablebucket-unreferencedfileremoval.html\n   * @default Enabled with default values\n   * @see https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-table-buckets-maintenance.html\n   */\n  readonly unreferencedFileRemoval?: UnreferencedFileRemoval;\n\n  /**\n   * AWS region that the table bucket exists in.\n   *\n   * @default - it's assumed the bucket is in the same region as the scope it's being imported into\n   */\n  readonly region?: string;\n\n  /**\n   * AWS Account ID of the table bucket owner.\n   *\n   * @default - it's assumed the bucket belongs to the same account as the scope it's being imported into\n   */\n  readonly account?: string;\n\n  /**\n   * Controls what happens to this table bucket it it stoped being managed by cloudformation.\n   *\n   * @default RETAIN\n   */\n  readonly removalPolicy?: RemovalPolicy;\n}\n\n/**\n * Everything needed to reference a specific table bucket.\n * The tableBucketName, region, and account can be provided explicitly\n * or will be inferred from the tableBucketArn\n */\nexport interface TableBucketAttributes {\n  /**\n   * AWS region this table bucket exists in\n   * @default region inferred from scope\n   */\n  readonly region?: string;\n  /**\n   * The accountId containing this table bucket\n   * @default account inferred from scope\n   */\n  readonly account?: string;\n  /**\n   * The table bucket name, unique per region\n   * @default tableBucketName inferred from arn\n   */\n  readonly tableBucketName?: string;\n  /**\n   * The table bucket's ARN.\n   * @default tableBucketArn constructed from region, account and tableBucketName are provided\n   */\n  readonly tableBucketArn?: string;\n}\n\n/**\n * An S3 table bucket with helpers for associated resource policies\n *\n * This bucket may not yet have all features that exposed by the underlying CfnTableBucket.\n *\n * @stateful\n * @example\n * const sampleTableBucket = new TableBucket(scope, 'ExampleTableBucket', {\n *   tableBucketName: 'example-bucket',\n *   // Optional fields:\n *   unreferencedFileRemoval: {\n *     noncurrentDays: 123,\n *     status: UnreferencedFileRemovalStatus.ENABLED,\n *     unreferencedDays: 123,\n *   },\n * });\n */\nexport class TableBucket extends TableBucketBase {\n  /**\n   * Defines a TableBucket construct from an external table bucket ARN.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param tableBucketArn Amazon Resource Name (arn) of the table bucket\n   */\n  public static fromTableBucketArn(scope: Construct, id: string, tableBucketArn: string): ITableBucket {\n    return TableBucket.fromTableBucketAttributes(scope, id, { tableBucketArn });\n  }\n\n  /**\n   * Defines a TableBucket construct that represents an external table bucket.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param attrs A `TableBucketAttributes` object. Can be manually created.\n   */\n  public static fromTableBucketAttributes(\n    scope: Construct,\n    id: string,\n    attrs: TableBucketAttributes,\n  ): ITableBucket {\n    const { tableBucketName, region, account, tableBucketArn } = validateTableBucketAttributes(scope, attrs);\n    TableBucket.validateTableBucketName(tableBucketName);\n    class Import extends TableBucketBase {\n      public readonly tableBucketName = tableBucketName!;\n      public readonly tableBucketArn = tableBucketArn;\n      public readonly tableBucketPolicy?: TableBucketPolicy;\n      public readonly region = region;\n      public readonly account = account;\n      protected autoCreatePolicy: boolean = false;\n\n      /**\n       * Exports this bucket from the stack.\n       */\n      public export() {\n        return attrs;\n      }\n    }\n\n    return new Import(scope, id, {\n      account,\n      region,\n      physicalName: tableBucketName,\n    });\n  }\n\n  /**\n   * Throws an exception if the given table bucket name is not valid.\n   *\n   * @param bucketName name of the bucket.\n   */\n  public static validateTableBucketName(\n    bucketName: string | undefined,\n  ) {\n    if (bucketName == undefined || Token.isUnresolved(bucketName)) {\n      // the name is a late-bound value, not a defined string, so skip validation\n      return;\n    }\n\n    const errors: string[] = [];\n\n    // Length validation\n    if (bucketName.length < 3 || bucketName.length > 63) {\n      errors.push(\n        'Bucket name must be at least 3 and no more than 63 characters',\n      );\n    }\n\n    // Character set validation\n    const illegalCharsetRegEx = /[^a-z0-9-]/;\n    const allowedEdgeCharsetRegEx = /[a-z0-9]/;\n\n    const illegalCharMatch = bucketName.match(illegalCharsetRegEx);\n    if (illegalCharMatch) {\n      errors.push(\n        'Bucket name must only contain lowercase characters, numbers, and hyphens (-)' +\n          ` (offset: ${illegalCharMatch.index})`,\n      );\n    }\n\n    // Edge character validation\n    if (!allowedEdgeCharsetRegEx.test(bucketName.charAt(0))) {\n      errors.push(\n        'Bucket name must start with a lowercase letter or number (offset: 0)',\n      );\n    }\n    if (\n      !allowedEdgeCharsetRegEx.test(bucketName.charAt(bucketName.length - 1))\n    ) {\n      errors.push(\n        `Bucket name must end with a lowercase letter or number (offset: ${\n          bucketName.length - 1\n        })`,\n      );\n    }\n\n    if (errors.length > 0) {\n      throw new UnscopedValidationError(\n        `Invalid S3 table bucket name (value: ${bucketName})${EOL}${errors.join(EOL)}`,\n      );\n    }\n  }\n\n  /**\n   * Throws an exception if the given unreferencedFileRemovalProperty is not valid.\n   * @param unreferencedFileRemoval configuration for the table bucket\n   */\n  public static validateUnreferencedFileRemoval(\n    unreferencedFileRemoval?: UnreferencedFileRemoval,\n  ): void {\n    // Skip validation if property is not defined\n    if (!unreferencedFileRemoval) {\n      return;\n    }\n\n    const { noncurrentDays, status, unreferencedDays } = unreferencedFileRemoval;\n\n    const errors: string[] = [];\n\n    if (noncurrentDays != undefined) {\n      if (noncurrentDays < 1) {\n        errors.push('noncurrentDays must be at least 1 day');\n      }\n      if (!Number.isInteger(noncurrentDays)) {\n        errors.push('noncurrentDays must be a whole number');\n      }\n    }\n\n    if (unreferencedDays != undefined) {\n      if (unreferencedDays < 1) {\n        errors.push('unreferencedDays must be at least 1 day');\n      }\n      if (!Number.isInteger(noncurrentDays)) {\n        errors.push('unreferencedDays must be a whole number');\n      }\n    }\n\n    const allowedStatus = ['Enabled', 'Disabled'];\n    if (status != undefined && !allowedStatus.includes(status)) {\n      errors.push('status must be one of \\'Enabled\\' or \\'Disabled\\'');\n    }\n\n    if (errors.length > 0) {\n      throw new UnscopedValidationError(\n        `Invalid UnreferencedFileRemovalProperty})${EOL}${errors.join(EOL)}`,\n      );\n    }\n  }\n\n  /**\n   * The underlying CfnTableBucket L1 resource\n   * @internal\n   */\n  private readonly _resource: s3tables.CfnTableBucket;\n\n  /**\n   * The resource policy for this tableBucket.\n   */\n  public readonly tableBucketPolicy?: TableBucketPolicy;\n\n  /**\n   * The unique Amazon Resource Name (arn) of this table bucket\n   */\n  public readonly tableBucketArn: string;\n\n  /**\n   * The name of this table bucket\n   */\n  public readonly tableBucketName: string;\n\n  protected autoCreatePolicy: boolean = true;\n\n  constructor(scope: Construct, id: string, props: TableBucketProps) {\n    super(scope, id, {\n      physicalName: props.tableBucketName,\n    });\n\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    TableBucket.validateTableBucketName(props.tableBucketName);\n    TableBucket.validateUnreferencedFileRemoval(props.unreferencedFileRemoval);\n\n    this._resource = new s3tables.CfnTableBucket(this, id, {\n      tableBucketName: props.tableBucketName,\n      unreferencedFileRemoval: {\n        ...props.unreferencedFileRemoval,\n        noncurrentDays: props.unreferencedFileRemoval?.noncurrentDays,\n        unreferencedDays: props.unreferencedFileRemoval?.unreferencedDays,\n      },\n    });\n\n    this.tableBucketName = this.getResourceNameAttribute(this._resource.ref);\n    this.tableBucketArn = this._resource.attrTableBucketArn;\n    this._resource.applyRemovalPolicy(props.removalPolicy);\n  }\n}\n\n"]}

package/lib/util.d.ts

@@ -0,0 +1,17 @@
+import { IConstruct } from 'constructs';
+import { TableBucketAttributes } from './table-bucket';
+export declare const S3_TABLES_SERVICE = "s3tables";
+export declare function parseTableBucketArn(construct: IConstruct, props: TableBucketAttributes): string;
+export declare function parseTableBucketName(construct: IConstruct, props: TableBucketAttributes): string;
+export declare function parseTableBucketRegion(construct: IConstruct, props: TableBucketAttributes): string | undefined;
+export declare function parseTableBucketAccount(construct: IConstruct, props: TableBucketAttributes): string | undefined;
+/**
+ * @returns populated attributes from given scope and attributes
+ * @throws ValidationError if any of the required attribures are missing
+ */
+export declare function validateTableBucketAttributes(construct: IConstruct, props: TableBucketAttributes): {
+    tableBucketName: string;
+    account: string | undefined;
+    region: string | undefined;
+    tableBucketArn: string;
+};