@aws-cdk/aws-dynamodb/lib/table.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.TableClass = exports.StreamViewType = exports.ProjectionType = exports.BillingMode = exports.AttributeType = exports.Table = exports.TableEncryption = exports.Operation = void 0;
const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const appscaling = require("@aws-cdk/aws-applicationautoscaling");
const cloudwatch = require("@aws-cdk/aws-cloudwatch");
const iam = require("@aws-cdk/aws-iam");
const kms = require("@aws-cdk/aws-kms");
const core_1 = require("@aws-cdk/core");
const dynamodb_canned_metrics_generated_1 = require("./dynamodb-canned-metrics.generated");
const dynamodb_generated_1 = require("./dynamodb.generated");
const perms = require("./perms");
const replica_provider_1 = require("./replica-provider");
const scalable_table_attribute_1 = require("./scalable-table-attribute");
// keep this import separate from other imports to reduce chance for merge conflicts with v2-main
// eslint-disable-next-line no-duplicate-imports, import/order
const core_2 = require("@aws-cdk/core");
const HASH_KEY_TYPE = 'HASH';
const RANGE_KEY_TYPE = 'RANGE';
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-secondary-indexes
const MAX_LOCAL_SECONDARY_INDEX_COUNT = 5;
/**
 * Supported DynamoDB table operations.
 */
var Operation;
(function (Operation) {
    /** GetItem */
    Operation["GET_ITEM"] = "GetItem";
    /** BatchGetItem */
    Operation["BATCH_GET_ITEM"] = "BatchGetItem";
    /** Scan */
    Operation["SCAN"] = "Scan";
    /** Query */
    Operation["QUERY"] = "Query";
    /** GetRecords */
    Operation["GET_RECORDS"] = "GetRecords";
    /** PutItem */
    Operation["PUT_ITEM"] = "PutItem";
    /** DeleteItem */
    Operation["DELETE_ITEM"] = "DeleteItem";
    /** UpdateItem */
    Operation["UPDATE_ITEM"] = "UpdateItem";
    /** BatchWriteItem */
    Operation["BATCH_WRITE_ITEM"] = "BatchWriteItem";
    /** TransactWriteItems */
    Operation["TRANSACT_WRITE_ITEMS"] = "TransactWriteItems";
    /** TransactGetItems */
    Operation["TRANSACT_GET_ITEMS"] = "TransactGetItems";
    /** ExecuteTransaction */
    Operation["EXECUTE_TRANSACTION"] = "ExecuteTransaction";
    /** BatchExecuteStatement */
    Operation["BATCH_EXECUTE_STATEMENT"] = "BatchExecuteStatement";
    /** ExecuteStatement */
    Operation["EXECUTE_STATEMENT"] = "ExecuteStatement";
})(Operation = exports.Operation || (exports.Operation = {}));
/**
 * What kind of server-side encryption to apply to this table.
 */
var TableEncryption;
(function (TableEncryption) {
    /**
     * Server-side KMS encryption with a master key owned by AWS.
     */
    TableEncryption["DEFAULT"] = "AWS_OWNED";
    /**
     * Server-side KMS encryption with a customer master key managed by customer.
     * If `encryptionKey` is specified, this key will be used, otherwise, one will be defined.
     *
     * > **NOTE**: if `encryptionKey` is not specified and the `Table` construct creates
     * > a KMS key for you, the key will be created with default permissions. If you are using
     * > CDKv2, these permissions will be sufficient to enable the key for use with DynamoDB tables.
     * > If you are using CDKv1, make sure the feature flag `@aws-cdk/aws-kms:defaultKeyPolicies`
     * > is set to `true` in your `cdk.json`.
     */
    TableEncryption["CUSTOMER_MANAGED"] = "CUSTOMER_MANAGED";
    /**
     * Server-side KMS encryption with a master key managed by AWS.
     */
    TableEncryption["AWS_MANAGED"] = "AWS_MANAGED";
})(TableEncryption = exports.TableEncryption || (exports.TableEncryption = {}));
class TableBase extends core_1.Resource {
    constructor() {
        super(...arguments);
        this.regionalArns = new Array();
    }
    /**
     * Adds an IAM policy statement associated with this table to an IAM
     * principal's policy.
     *
     * If `encryptionKey` is present, appropriate grants to the key needs to be added
     * separately using the `table.encryptionKey.grant*` methods.
     *
     * @param grantee The principal (no-op if undefined)
     * @param actions The set of actions to allow (i.e. "dynamodb:PutItem", "dynamodb:GetItem", ...)
     */
    grant(grantee, ...actions) {
        return iam.Grant.addToPrincipal({
            grantee,
            actions,
            resourceArns: [
                this.tableArn,
                core_1.Lazy.string({ produce: () => this.hasIndex ? `${this.tableArn}/index/*` : core_1.Aws.NO_VALUE }),
                ...this.regionalArns,
                ...this.regionalArns.map(arn => core_1.Lazy.string({
                    produce: () => this.hasIndex ? `${arn}/index/*` : core_1.Aws.NO_VALUE,
                })),
            ],
            scope: this,
        });
    }
    /**
     * Adds an IAM policy statement associated with this table's stream to an
     * IAM principal's policy.
     *
     * If `encryptionKey` is present, appropriate grants to the key needs to be added
     * separately using the `table.encryptionKey.grant*` methods.
     *
     * @param grantee The principal (no-op if undefined)
     * @param actions The set of actions to allow (i.e. "dynamodb:DescribeStream", "dynamodb:GetRecords", ...)
     */
    grantStream(grantee, ...actions) {
        if (!this.tableStreamArn) {
            throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);
        }
        return iam.Grant.addToPrincipal({
            grantee,
            actions,
            resourceArns: [this.tableStreamArn],
            scope: this,
        });
    }
    /**
     * Permits an IAM principal all data read operations from this table:
     * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan, DescribeTable.
     *
     * Appropriate grants will also be added to the customer-managed KMS key
     * if one was configured.
     *
     * @param grantee The principal to grant access to
     */
    grantReadData(grantee) {
        const tableActions = perms.READ_DATA_ACTIONS.concat(perms.DESCRIBE_TABLE);
        return this.combinedGrant(grantee, { keyActions: perms.KEY_READ_ACTIONS, tableActions });
    }
    /**
     * Permits an IAM Principal to list streams attached to current dynamodb table.
     *
     * @param grantee The principal (no-op if undefined)
     */
    grantTableListStreams(grantee) {
        if (!this.tableStreamArn) {
            throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);
        }
        return iam.Grant.addToPrincipal({
            grantee,
            actions: ['dynamodb:ListStreams'],
            resourceArns: ['*'],
        });
    }
    /**
     * Permits an IAM principal all stream data read operations for this
     * table's stream:
     * DescribeStream, GetRecords, GetShardIterator, ListStreams.
     *
     * Appropriate grants will also be added to the customer-managed KMS key
     * if one was configured.
     *
     * @param grantee The principal to grant access to
     */
    grantStreamRead(grantee) {
        this.grantTableListStreams(grantee);
        return this.combinedGrant(grantee, { keyActions: perms.KEY_READ_ACTIONS, streamActions: perms.READ_STREAM_DATA_ACTIONS });
    }
    /**
     * Permits an IAM principal all data write operations to this table:
     * BatchWriteItem, PutItem, UpdateItem, DeleteItem, DescribeTable.
     *
     * Appropriate grants will also be added to the customer-managed KMS key
     * if one was configured.
     *
     * @param grantee The principal to grant access to
     */
    grantWriteData(grantee) {
        const tableActions = perms.WRITE_DATA_ACTIONS.concat(perms.DESCRIBE_TABLE);
        const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);
        return this.combinedGrant(grantee, { keyActions, tableActions });
    }
    /**
     * Permits an IAM principal to all data read/write operations to this table.
     * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan,
     * BatchWriteItem, PutItem, UpdateItem, DeleteItem, DescribeTable
     *
     * Appropriate grants will also be added to the customer-managed KMS key
     * if one was configured.
     *
     * @param grantee The principal to grant access to
     */
    grantReadWriteData(grantee) {
        const tableActions = perms.READ_DATA_ACTIONS.concat(perms.WRITE_DATA_ACTIONS).concat(perms.DESCRIBE_TABLE);
        const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);
        return this.combinedGrant(grantee, { keyActions, tableActions });
    }
    /**
     * Permits all DynamoDB operations ("dynamodb:*") to an IAM principal.
     *
     * Appropriate grants will also be added to the customer-managed KMS key
     * if one was configured.
     *
     * @param grantee The principal to grant access to
     */
    grantFullAccess(grantee) {
        const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);
        return this.combinedGrant(grantee, { keyActions, tableActions: ['dynamodb:*'] });
    }
    /**
     * Return the given named metric for this Table
     *
     * By default, the metric will be calculated as a sum over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metric(metricName, props) {
        return new cloudwatch.Metric({
            namespace: 'AWS/DynamoDB',
            metricName,
            dimensionsMap: {
                TableName: this.tableName,
            },
            ...props,
        }).attachTo(this);
    }
    /**
     * Metric for the consumed read capacity units this table
     *
     * By default, the metric will be calculated as a sum over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metricConsumedReadCapacityUnits(props) {
        return this.cannedMetric(dynamodb_canned_metrics_generated_1.DynamoDBMetrics.consumedReadCapacityUnitsSum, props);
    }
    /**
     * Metric for the consumed write capacity units this table
     *
     * By default, the metric will be calculated as a sum over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metricConsumedWriteCapacityUnits(props) {
        return this.cannedMetric(dynamodb_canned_metrics_generated_1.DynamoDBMetrics.consumedWriteCapacityUnitsSum, props);
    }
    /**
     * Metric for the system errors this table
     *
     * @deprecated use `metricSystemErrorsForOperations`.
     */
    metricSystemErrors(props) {
        if (!props?.dimensions?.Operation && !props?.dimensionsMap?.Operation) {
            // 'Operation' must be passed because its an operational metric.
            throw new Error("'Operation' dimension must be passed for the 'SystemErrors' metric.");
        }
        const dimensionsMap = {
            TableName: this.tableName,
            ...props?.dimensions ?? {},
            ...props?.dimensionsMap ?? {},
        };
        return this.metric('SystemErrors', { statistic: 'sum', ...props, dimensionsMap });
    }
    /**
     * Metric for the user errors. Note that this metric reports user errors across all
     * the tables in the account and region the table resides in.
     *
     * By default, the metric will be calculated as a sum over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metricUserErrors(props) {
        if (props?.dimensions) {
            throw new Error("'dimensions' is not supported for the 'UserErrors' metric");
        }
        // overriding 'dimensions' here because this metric is an account metric.
        // see 'UserErrors' in https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/metrics-dimensions.html
        return this.metric('UserErrors', { statistic: 'sum', ...props, dimensionsMap: {} });
    }
    /**
     * Metric for the conditional check failed requests this table
     *
     * By default, the metric will be calculated as a sum over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metricConditionalCheckFailedRequests(props) {
        return this.metric('ConditionalCheckFailedRequests', { statistic: 'sum', ...props });
    }
    /**
     * How many requests are throttled on this table
     *
     * Default: sum over 5 minutes
     *
     * @deprecated Do not use this function. It returns an invalid metric. Use `metricThrottledRequestsForOperation` instead.
     */
    metricThrottledRequests(props) {
        return this.metric('ThrottledRequests', { statistic: 'sum', ...props });
    }
    /**
     * How many requests are throttled on this table, for the given operation
     *
     * Default: sum over 5 minutes
     */
    metricThrottledRequestsForOperation(operation, props) {
        return new cloudwatch.Metric({
            ...dynamodb_canned_metrics_generated_1.DynamoDBMetrics.throttledRequestsSum({ Operation: operation, TableName: this.tableName }),
            ...props,
        }).attachTo(this);
    }
    /**
     * Metric for the successful request latency this table.
     *
     * By default, the metric will be calculated as an average over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metricSuccessfulRequestLatency(props) {
        if (!props?.dimensions?.Operation && !props?.dimensionsMap?.Operation) {
            throw new Error("'Operation' dimension must be passed for the 'SuccessfulRequestLatency' metric.");
        }
        const dimensionsMap = {
            TableName: this.tableName,
            Operation: props.dimensionsMap?.Operation ?? props.dimensions?.Operation,
        };
        return new cloudwatch.Metric({
            ...dynamodb_canned_metrics_generated_1.DynamoDBMetrics.successfulRequestLatencyAverage(dimensionsMap),
            ...props,
            dimensionsMap,
        }).attachTo(this);
    }
    /**
     * Metric for the system errors this table.
     *
     * This will sum errors across all possible operations.
     * Note that by default, each individual metric will be calculated as a sum over a period of 5 minutes.
     * You can customize this by using the `statistic` and `period` properties.
     */
    metricSystemErrorsForOperations(props) {
        if (props?.dimensions?.Operation) {
            throw new Error("The Operation dimension is not supported. Use the 'operations' property.");
        }
        const operations = props?.operations ?? Object.values(Operation);
        const values = this.createMetricsForOperations('SystemErrors', operations, { statistic: 'sum', ...props });
        const sum = new cloudwatch.MathExpression({
            expression: `${Object.keys(values).join(' + ')}`,
            usingMetrics: { ...values },
            color: props?.color,
            label: 'Sum of errors across all operations',
            period: props?.period,
        });
        return sum;
    }
    /**
     * Create a map of metrics that can be used in a math expression.
     *
     * Using the return value of this function as the `usingMetrics` property in `cloudwatch.MathExpression` allows you to
     * use the keys of this map as metric names inside you expression.
     *
     * @param metricName The metric name.
     * @param operations The list of operations to create metrics for.
     * @param props Properties for the individual metrics.
     * @param metricNameMapper Mapper function to allow controlling the individual metric name per operation.
     */
    createMetricsForOperations(metricName, operations, props, metricNameMapper) {
        const metrics = {};
        const mapper = metricNameMapper ?? (op => op.toLowerCase());
        if (props?.dimensions?.Operation) {
            throw new Error('Invalid properties. Operation dimension is not supported when calculating operational metrics');
        }
        for (const operation of operations) {
            const metric = this.metric(metricName, {
                ...props,
                dimensionsMap: {
                    TableName: this.tableName,
                    Operation: operation,
                    ...props?.dimensions,
                },
            });
            const operationMetricName = mapper(operation);
            const firstChar = operationMetricName.charAt(0);
            if (firstChar === firstChar.toUpperCase()) {
                // https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax
                throw new Error(`Mapper generated an illegal operation metric name: ${operationMetricName}. Must start with a lowercase letter`);
            }
            metrics[operationMetricName] = metric;
        }
        return metrics;
    }
    /**
     * Adds an IAM policy statement associated with this table to an IAM
     * principal's policy.
     * @param grantee The principal (no-op if undefined)
     * @param opts Options for keyActions, tableActions and streamActions
     */
    combinedGrant(grantee, opts) {
        if (opts.tableActions) {
            const resources = [this.tableArn,
                core_1.Lazy.string({ produce: () => this.hasIndex ? `${this.tableArn}/index/*` : core_1.Aws.NO_VALUE }),
                ...this.regionalArns,
                ...this.regionalArns.map(arn => core_1.Lazy.string({
                    produce: () => this.hasIndex ? `${arn}/index/*` : core_1.Aws.NO_VALUE,
                }))];
            const ret = iam.Grant.addToPrincipal({
                grantee,
                actions: opts.tableActions,
                resourceArns: resources,
                scope: this,
            });
            if (this.encryptionKey && opts.keyActions) {
                this.encryptionKey.grant(grantee, ...opts.keyActions);
            }
            return ret;
        }
        if (opts.streamActions) {
            if (!this.tableStreamArn) {
                throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);
            }
            const resources = [this.tableStreamArn];
            const ret = iam.Grant.addToPrincipal({
                grantee,
                actions: opts.streamActions,
                resourceArns: resources,
                scope: this,
            });
            return ret;
        }
        throw new Error(`Unexpected 'action', ${opts.tableActions || opts.streamActions}`);
    }
    cannedMetric(fn, props) {
        return new cloudwatch.Metric({
            ...fn({ TableName: this.tableName }),
            ...props,
        }).attachTo(this);
    }
}
/**
 * Provides a DynamoDB table.
 */
class Table extends TableBase {
    constructor(scope, id, props) {
        super(scope, id, {
            physicalName: props.tableName,
        });
        this.keySchema = new Array();
        this.attributeDefinitions = new Array();
        this.globalSecondaryIndexes = new Array();
        this.localSecondaryIndexes = new Array();
        this.secondaryIndexSchemas = new Map();
        this.nonKeyAttributes = new Set();
        this.tableScaling = {};
        this.indexScaling = new Map();
        this.globalReplicaCustomResources = new Array();
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_TableProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, Table);
            }
            throw error;
        }
        const { sseSpecification, encryptionKey } = this.parseEncryption(props);
        let streamSpecification;
        if (props.replicationRegions) {
            if (props.stream && props.stream !== StreamViewType.NEW_AND_OLD_IMAGES) {
                throw new Error('`stream` must be set to `NEW_AND_OLD_IMAGES` when specifying `replicationRegions`');
            }
            streamSpecification = { streamViewType: StreamViewType.NEW_AND_OLD_IMAGES };
            this.billingMode = props.billingMode ?? BillingMode.PAY_PER_REQUEST;
        }
        else {
            this.billingMode = props.billingMode ?? BillingMode.PROVISIONED;
            if (props.stream) {
                streamSpecification = { streamViewType: props.stream };
            }
        }
        this.validateProvisioning(props);
        this.table = new dynamodb_generated_1.CfnTable(this, 'Resource', {
            tableName: this.physicalName,
            keySchema: this.keySchema,
            attributeDefinitions: this.attributeDefinitions,
            globalSecondaryIndexes: core_1.Lazy.any({ produce: () => this.globalSecondaryIndexes }, { omitEmptyArray: true }),
            localSecondaryIndexes: core_1.Lazy.any({ produce: () => this.localSecondaryIndexes }, { omitEmptyArray: true }),
            pointInTimeRecoverySpecification: props.pointInTimeRecovery != null ? { pointInTimeRecoveryEnabled: props.pointInTimeRecovery } : undefined,
            billingMode: this.billingMode === BillingMode.PAY_PER_REQUEST ? this.billingMode : undefined,
            provisionedThroughput: this.billingMode === BillingMode.PAY_PER_REQUEST ? undefined : {
                readCapacityUnits: props.readCapacity || 5,
                writeCapacityUnits: props.writeCapacity || 5,
            },
            sseSpecification,
            streamSpecification,
            tableClass: props.tableClass,
            timeToLiveSpecification: props.timeToLiveAttribute ? { attributeName: props.timeToLiveAttribute, enabled: true } : undefined,
            contributorInsightsSpecification: props.contributorInsightsEnabled !== undefined ? { enabled: props.contributorInsightsEnabled } : undefined,
            kinesisStreamSpecification: props.kinesisStream ? { streamArn: props.kinesisStream.streamArn } : undefined,
        });
        this.table.applyRemovalPolicy(props.removalPolicy);
        this.encryptionKey = encryptionKey;
        this.tableArn = this.getResourceArnAttribute(this.table.attrArn, {
            service: 'dynamodb',
            resource: 'table',
            resourceName: this.physicalName,
        });
        this.tableName = this.getResourceNameAttribute(this.table.ref);
        if (props.tableName) {
            this.node.addMetadata('aws:cdk:hasPhysicalName', this.tableName);
        }
        this.tableStreamArn = streamSpecification ? this.table.attrStreamArn : undefined;
        this.scalingRole = this.makeScalingRole();
        this.addKey(props.partitionKey, HASH_KEY_TYPE);
        this.tablePartitionKey = props.partitionKey;
        if (props.sortKey) {
            this.addKey(props.sortKey, RANGE_KEY_TYPE);
            this.tableSortKey = props.sortKey;
        }
        if (props.replicationRegions && props.replicationRegions.length > 0) {
            this.createReplicaTables(props.replicationRegions, props.replicationTimeout, props.waitForReplicationToFinish);
        }
    }
    /**
     * Permits an IAM Principal to list all DynamoDB Streams.
     * @deprecated Use {@link #grantTableListStreams} for more granular permission
     * @param grantee The principal (no-op if undefined)
     */
    static grantListStreams(grantee) {
        try {
            jsiiDeprecationWarnings.print("@aws-cdk/aws-dynamodb.Table#grantListStreams", "Use {@link #grantTableListStreams} for more granular permission");
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.grantListStreams);
            }
            throw error;
        }
        return iam.Grant.addToPrincipal({
            grantee,
            actions: ['dynamodb:ListStreams'],
            resourceArns: ['*'],
        });
    }
    /**
     * Creates a Table construct that represents an external table via table name.
     *
     * @param scope The parent creating construct (usually `this`).
     * @param id The construct's name.
     * @param tableName The table's name.
     */
    static fromTableName(scope, id, tableName) {
        return Table.fromTableAttributes(scope, id, { tableName });
    }
    /**
     * Creates a Table construct that represents an external table via table arn.
     *
     * @param scope The parent creating construct (usually `this`).
     * @param id The construct's name.
     * @param tableArn The table's ARN.
     */
    static fromTableArn(scope, id, tableArn) {
        return Table.fromTableAttributes(scope, id, { tableArn });
    }
    /**
     * Creates a Table construct that represents an external table.
     *
     * @param scope The parent creating construct (usually `this`).
     * @param id The construct's name.
     * @param attrs A `TableAttributes` object.
     */
    static fromTableAttributes(scope, id, attrs) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_TableAttributes(attrs);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.fromTableAttributes);
            }
            throw error;
        }
        class Import extends TableBase {
            constructor(_tableArn, tableName, tableStreamArn) {
                super(scope, id);
                this.hasIndex = (attrs.globalIndexes ?? []).length > 0 ||
                    (attrs.localIndexes ?? []).length > 0;
                this.tableArn = _tableArn;
                this.tableName = tableName;
                this.tableStreamArn = tableStreamArn;
                this.encryptionKey = attrs.encryptionKey;
            }
        }
        let name;
        let arn;
        const stack = core_1.Stack.of(scope);
        if (!attrs.tableName) {
            if (!attrs.tableArn) {
                throw new Error('One of tableName or tableArn is required!');
            }
            arn = attrs.tableArn;
            const maybeTableName = stack.splitArn(attrs.tableArn, core_1.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
            if (!maybeTableName) {
                throw new Error('ARN for DynamoDB table must be in the form: ...');
            }
            name = maybeTableName;
        }
        else {
            if (attrs.tableArn) {
                throw new Error('Only one of tableArn or tableName can be provided');
            }
            name = attrs.tableName;
            arn = stack.formatArn({
                service: 'dynamodb',
                resource: 'table',
                resourceName: attrs.tableName,
            });
        }
        return new Import(arn, name, attrs.tableStreamArn);
    }
    /**
     * Add a global secondary index of table.
     *
     * @param props the property of global secondary index
     */
    addGlobalSecondaryIndex(props) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_GlobalSecondaryIndexProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addGlobalSecondaryIndex);
            }
            throw error;
        }
        this.validateProvisioning(props);
        this.validateIndexName(props.indexName);
        // build key schema and projection for index
        const gsiKeySchema = this.buildIndexKeySchema(props.partitionKey, props.sortKey);
        const gsiProjection = this.buildIndexProjection(props);
        this.globalSecondaryIndexes.push({
            indexName: props.indexName,
            keySchema: gsiKeySchema,
            projection: gsiProjection,
            provisionedThroughput: this.billingMode === BillingMode.PAY_PER_REQUEST ? undefined : {
                readCapacityUnits: props.readCapacity || 5,
                writeCapacityUnits: props.writeCapacity || 5,
            },
        });
        this.secondaryIndexSchemas.set(props.indexName, {
            partitionKey: props.partitionKey,
            sortKey: props.sortKey,
        });
        this.indexScaling.set(props.indexName, {});
    }
    /**
     * Add a local secondary index of table.
     *
     * @param props the property of local secondary index
     */
    addLocalSecondaryIndex(props) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_LocalSecondaryIndexProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.addLocalSecondaryIndex);
            }
            throw error;
        }
        // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-secondary-indexes
        if (this.localSecondaryIndexes.length >= MAX_LOCAL_SECONDARY_INDEX_COUNT) {
            throw new RangeError(`a maximum number of local secondary index per table is ${MAX_LOCAL_SECONDARY_INDEX_COUNT}`);
        }
        this.validateIndexName(props.indexName);
        // build key schema and projection for index
        const lsiKeySchema = this.buildIndexKeySchema(this.tablePartitionKey, props.sortKey);
        const lsiProjection = this.buildIndexProjection(props);
        this.localSecondaryIndexes.push({
            indexName: props.indexName,
            keySchema: lsiKeySchema,
            projection: lsiProjection,
        });
        this.secondaryIndexSchemas.set(props.indexName, {
            partitionKey: this.tablePartitionKey,
            sortKey: props.sortKey,
        });
    }
    /**
     * Enable read capacity scaling for this table
     *
     * @returns An object to configure additional AutoScaling settings
     */
    autoScaleReadCapacity(props) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_EnableScalingProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.autoScaleReadCapacity);
            }
            throw error;
        }
        if (this.tableScaling.scalableReadAttribute) {
            throw new Error('Read AutoScaling already enabled for this table');
        }
        if (this.billingMode === BillingMode.PAY_PER_REQUEST) {
            throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');
        }
        return this.tableScaling.scalableReadAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, 'ReadScaling', {
            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
            resourceId: `table/${this.tableName}`,
            dimension: 'dynamodb:table:ReadCapacityUnits',
            role: this.scalingRole,
            ...props,
        });
    }
    /**
     * Enable write capacity scaling for this table
     *
     * @returns An object to configure additional AutoScaling settings for this attribute
     */
    autoScaleWriteCapacity(props) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_EnableScalingProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.autoScaleWriteCapacity);
            }
            throw error;
        }
        if (this.tableScaling.scalableWriteAttribute) {
            throw new Error('Write AutoScaling already enabled for this table');
        }
        if (this.billingMode === BillingMode.PAY_PER_REQUEST) {
            throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');
        }
        this.tableScaling.scalableWriteAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, 'WriteScaling', {
            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
            resourceId: `table/${this.tableName}`,
            dimension: 'dynamodb:table:WriteCapacityUnits',
            role: this.scalingRole,
            ...props,
        });
        for (const globalReplicaCustomResource of this.globalReplicaCustomResources) {
            globalReplicaCustomResource.node.addDependency(this.tableScaling.scalableWriteAttribute);
        }
        return this.tableScaling.scalableWriteAttribute;
    }
    /**
     * Enable read capacity scaling for the given GSI
     *
     * @returns An object to configure additional AutoScaling settings for this attribute
     */
    autoScaleGlobalSecondaryIndexReadCapacity(indexName, props) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_EnableScalingProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.autoScaleGlobalSecondaryIndexReadCapacity);
            }
            throw error;
        }
        if (this.billingMode === BillingMode.PAY_PER_REQUEST) {
            throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');
        }
        const attributePair = this.indexScaling.get(indexName);
        if (!attributePair) {
            throw new Error(`No global secondary index with name ${indexName}`);
        }
        if (attributePair.scalableReadAttribute) {
            throw new Error('Read AutoScaling already enabled for this index');
        }
        return attributePair.scalableReadAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, `${indexName}ReadScaling`, {
            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
            resourceId: `table/${this.tableName}/index/${indexName}`,
            dimension: 'dynamodb:index:ReadCapacityUnits',
            role: this.scalingRole,
            ...props,
        });
    }
    /**
     * Enable write capacity scaling for the given GSI
     *
     * @returns An object to configure additional AutoScaling settings for this attribute
     */
    autoScaleGlobalSecondaryIndexWriteCapacity(indexName, props) {
        try {
            jsiiDeprecationWarnings._aws_cdk_aws_dynamodb_EnableScalingProps(props);
        }
        catch (error) {
            if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
                Error.captureStackTrace(error, this.autoScaleGlobalSecondaryIndexWriteCapacity);
            }
            throw error;
        }
        if (this.billingMode === BillingMode.PAY_PER_REQUEST) {
            throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');
        }
        const attributePair = this.indexScaling.get(indexName);
        if (!attributePair) {
            throw new Error(`No global secondary index with name ${indexName}`);
        }
        if (attributePair.scalableWriteAttribute) {
            throw new Error('Write AutoScaling already enabled for this index');
        }
        return attributePair.scalableWriteAttribute = new scalable_table_attribute_1.ScalableTableAttribute(this, `${indexName}WriteScaling`, {
            serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,
            resourceId: `table/${this.tableName}/index/${indexName}`,
            dimension: 'dynamodb:index:WriteCapacityUnits',
            role: this.scalingRole,
            ...props,
        });
    }
    /**
     * Get schema attributes of table or index.
     *
     * @returns Schema of table or index.
     */
    schema(indexName) {
        if (!indexName) {
            return {
                partitionKey: this.tablePartitionKey,
                sortKey: this.tableSortKey,
            };
        }
        let schema = this.secondaryIndexSchemas.get(indexName);
        if (!schema) {
            throw new Error(`Cannot find schema for index: ${indexName}. Use 'addGlobalSecondaryIndex' or 'addLocalSecondaryIndex' to add index`);
        }
        return schema;
    }
    /**
     * Validate the table construct.
     *
     * @returns an array of validation error message
     */
    validate() {
        const errors = new Array();
        if (!this.tablePartitionKey) {
            errors.push('a partition key must be specified');
        }
        if (this.localSecondaryIndexes.length > 0 && !this.tableSortKey) {
            errors.push('a sort key of the table must be specified to add local secondary indexes');
        }
        if (this.globalReplicaCustomResources.length > 0 && this.billingMode === BillingMode.PROVISIONED) {
            const writeAutoScaleAttribute = this.tableScaling.scalableWriteAttribute;
            if (!writeAutoScaleAttribute) {
                errors.push('A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity. ' +
                    'Use the autoScaleWriteCapacity() method to enable it.');
            }
            else if (!writeAutoScaleAttribute._scalingPolicyCreated) {
                errors.push('A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity with a policy. ' +
                    'Call one of the scaleOn*() methods of the object returned from autoScaleWriteCapacity()');
            }
        }
        return errors;
    }
    /**
     * Validate read and write capacity are not specified for on-demand tables (billing mode PAY_PER_REQUEST).
     *
     * @param props read and write capacity properties
     */
    validateProvisioning(props) {
        if (this.billingMode === BillingMode.PAY_PER_REQUEST) {
            if (props.readCapacity !== undefined || props.writeCapacity !== undefined) {
                throw new Error('you cannot provision read and write capacity for a table with PAY_PER_REQUEST billing mode');
            }
        }
    }
    /**
     * Validate index name to check if a duplicate name already exists.
     *
     * @param indexName a name of global or local secondary index
     */
    validateIndexName(indexName) {
        if (this.secondaryIndexSchemas.has(indexName)) {
            // a duplicate index name causes validation exception, status code 400, while trying to create CFN stack
            throw new Error(`a duplicate index name, ${indexName}, is not allowed`);
        }
    }
    /**
     * Validate non-key attributes by checking limits within secondary index, which may vary in future.
     *
     * @param nonKeyAttributes a list of non-key attribute names
     */
    validateNonKeyAttributes(nonKeyAttributes) {
        if (this.nonKeyAttributes.size + nonKeyAttributes.length > 100) {
            // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-secondary-indexes
            throw new RangeError('a maximum number of nonKeyAttributes across all of secondary indexes is 100');
        }
        // store all non-key attributes
        nonKeyAttributes.forEach(att => this.nonKeyAttributes.add(att));
    }
    buildIndexKeySchema(partitionKey, sortKey) {
        this.registerAttribute(partitionKey);
        const indexKeySchema = [
            { attributeName: partitionKey.name, keyType: HASH_KEY_TYPE },
        ];
        if (sortKey) {
            this.registerAttribute(sortKey);
            indexKeySchema.push({ attributeName: sortKey.name, keyType: RANGE_KEY_TYPE });
        }
        return indexKeySchema;
    }
    buildIndexProjection(props) {
        if (props.projectionType === ProjectionType.INCLUDE && !props.nonKeyAttributes) {
            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-projectionobject.html
            throw new Error(`non-key attributes should be specified when using ${ProjectionType.INCLUDE} projection type`);
        }
        if (props.projectionType !== ProjectionType.INCLUDE && props.nonKeyAttributes) {
            // this combination causes validation exception, status code 400, while trying to create CFN stack
            throw new Error(`non-key attributes should not be specified when not using ${ProjectionType.INCLUDE} projection type`);
        }
        if (props.nonKeyAttributes) {
            this.validateNonKeyAttributes(props.nonKeyAttributes);
        }
        return {
            projectionType: props.projectionType ?? ProjectionType.ALL,
            nonKeyAttributes: props.nonKeyAttributes ?? undefined,
        };
    }
    findKey(keyType) {
        return this.keySchema.find(prop => prop.keyType === keyType);
    }
    addKey(attribute, keyType) {
        const existingProp = this.findKey(keyType);
        if (existingProp) {
            throw new Error(`Unable to set ${attribute.name} as a ${keyType} key, because ${existingProp.attributeName} is a ${keyType} key`);
        }
        this.registerAttribute(attribute);
        this.keySchema.push({
            attributeName: attribute.name,
            keyType,
        });
        return this;
    }
    /**
     * Register the key attribute of table or secondary index to assemble attribute definitions of TableResourceProps.
     *
     * @param attribute the key attribute of table or secondary index
     */
    registerAttribute(attribute) {
        const { name, type } = attribute;
        const existingDef = this.attributeDefinitions.find(def => def.attributeName === name);
        if (existingDef && existingDef.attributeType !== type) {
            throw new Error(`Unable to specify ${name} as ${type} because it was already defined as ${existingDef.attributeType}`);
        }
        if (!existingDef) {
            this.attributeDefinitions.push({
                attributeName: name,
                attributeType: type,
            });
        }
    }
    /**
     * Return the role that will be used for AutoScaling
     */
    makeScalingRole() {
        // Use a Service Linked Role.
        // https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html
        return iam.Role.fromRoleArn(this, 'ScalingRole', core_1.Stack.of(this).formatArn({
            service: 'iam',
            region: '',
            resource: 'role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com',
            resourceName: 'AWSServiceRoleForApplicationAutoScaling_DynamoDBTable',
        }));
    }
    /**
     * Creates replica tables
     *
     * @param regions regions where to create tables
     */
    createReplicaTables(regions, timeout, waitForReplicationToFinish) {
        const stack = core_1.Stack.of(this);
        if (!core_1.Token.isUnresolved(stack.region) && regions.includes(stack.region)) {
            throw new Error('`replicationRegions` cannot include the region where this stack is deployed.');
        }
        const provider = replica_provider_1.ReplicaProvider.getOrCreate(this, { timeout });
        // Documentation at https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2gt_IAM.html
        // is currently incorrect. AWS Support recommends `dynamodb:*` in both source and destination regions
        const onEventHandlerPolicy = new SourceTableAttachedPolicy(this, provider.onEventHandler.role);
        const isCompleteHandlerPolicy = new SourceTableAttachedPolicy(this, provider.isCompleteHandler.role);
        // Permissions in the source region
        this.grant(onEventHandlerPolicy, 'dynamodb:*');
        this.grant(isCompleteHandlerPolicy, 'dynamodb:DescribeTable');
        let previousRegion;
        let previousRegionCondition;
        for (const region of new Set(regions)) { // Remove duplicates
            // Use multiple custom resources because multiple create/delete
            // updates cannot be combined in a single API call.
            const currentRegion = new core_1.CustomResource(this, `Replica${region}`, {
                serviceToken: provider.provider.serviceToken,
                resourceType: 'Custom::DynamoDBReplica',
                properties: {
                    TableName: this.tableName,
                    Region: region,
                    SkipReplicationCompletedWait: waitForReplicationToFinish == null
                        ? undefined
                        // CFN changes Custom Resource properties to strings anyways,
                        // so let's do that ourselves to make it clear in the handler this is a string, not a boolean
                        : (!waitForReplicationToFinish).toString(),
                },
            });
            currentRegion.node.addDependency(onEventHandlerPolicy.policy, isCompleteHandlerPolicy.policy);
            this.globalReplicaCustomResources.push(currentRegion);
            // Deploy time check to prevent from creating a replica in the region
            // where this stack is deployed. Only needed for environment agnostic
            // stacks.
            let createReplica;
            if (core_1.Token.isUnresolved(stack.region)) {
                createReplica = new core_1.CfnCondition(this, `StackRegionNotEquals${region}`, {
                    expression: core_1.Fn.conditionNot(core_1.Fn.conditionEquals(region, core_1.Aws.REGION)),
                });
                const cfnCustomResource = currentRegion.node.defaultChild;
                cfnCustomResource.cfnOptions.condition = createReplica;
            }
            // Save regional arns for grantXxx() methods
            this.regionalArns.push(stack.formatArn({
                region,
                service: 'dynamodb',
                resource: 'table',
                resourceName: this.tableName,
            }));
            // We need to create/delete regions sequentially because we cannot
            // have multiple table updates at the same time. The `isCompleteHandler`
            // of the provider waits until the replica is in an ACTIVE state.
            if (previousRegion) {
                if (previousRegionCondition) {
                    // we can't simply use a Dependency,
                    // because the previousRegion is protected by the "different region" Condition,
                    // and you can't have Fn::If in DependsOn.
                    // Instead, rely on Ref adding a dependency implicitly!
                    const previousRegionCfnResource = previousRegion.node.defaultChild;
                    const currentRegionCfnResource = currentRegion.node.defaultChild;
                    currentRegionCfnResource.addMetadata('DynamoDbReplicationDependency', core_1.Fn.conditionIf(previousRegionCondition.logicalId, previousRegionCfnResource.ref, core_1.Aws.NO_VALUE));
                }
                else {
                    currentRegion.node.addDependency(previousRegion);
                }
            }
            previousRegion = currentRegion;
            previousRegionCondition = createReplica;
        }
        // Permissions in the destination regions (outside of the loop to
        // minimize statements in the policy)
        onEventHandlerPolicy.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({
            actions: ['dynamodb:*'],
            resources: this.regionalArns,
        }));
    }
    /**
     * Whether this table has indexes
     */
    get hasIndex() {
        return this.globalSecondaryIndexes.length + this.localSecondaryIndexes.length > 0;
    }
    /**
     * Set up key properties and return the Table encryption property from the
     * user's configuration.
     */
    parseEncryption(props) {
        let encryptionType = props.encryption;
        if (encryptionType != null && props.serverSideEncryption != null) {
            throw new Error('Only one of encryption and serverSideEncryption can be specified, but both were provided');
        }
        if (props.serverSideEncryption && props.encryptionKey) {
            throw new Error('encryptionKey cannot be specified when serverSideEncryption is specified. Use encryption instead');
        }
        if (encryptionType === undefined) {
            encryptionType = props.encryptionKey != null
                // If there is a configured encryptionKey, the encryption is implicitly CUSTOMER_MANAGED
                ? TableEncryption.CUSTOMER_MANAGED
                // Otherwise, if severSideEncryption is enabled, it's AWS_MANAGED; else undefined (do not set anything)
                : props.serverSideEncryption ? TableEncryption.AWS_MANAGED : undefined;
        }
        if (encryptionType !== TableEncryption.CUSTOMER_MANAGED && props.encryptionKey) {
            throw new Error('`encryptionKey cannot be specified unless encryption is set to TableEncryption.CUSTOMER_MANAGED (it was set to ${encryptionType})`');
        }
        if (encryptionType === TableEncryption.CUSTOMER_MANAGED && props.replicationRegions) {
            throw new Error('TableEncryption.CUSTOMER_MANAGED is not supported by DynamoDB Global Tables (where replicationRegions was set)');
        }
        switch (encryptionType) {
            case TableEncryption.CUSTOMER_MANAGED:
                const encryptionKey = props.encryptionKey ?? new kms.Key(this, 'Key', {
                    description: `Customer-managed key auto-created for encrypting DynamoDB table at ${this.node.path}`,
                    enableKeyRotation: true,
                });
                return {
                    sseSpecification: { sseEnabled: true, kmsMasterKeyId: encryptionKey.keyArn, sseType: 'KMS' },
                    encryptionKey,
                };
            case TableEncryption.AWS_MANAGED:
                // Not specifying "sseType: 'KMS'" here because it would cause phony changes to existing stacks.
                return { sseSpecification: { sseEnabled: true } };
            case TableEncryption.DEFAULT:
                return { sseSpecification: { sseEnabled: false } };
            case undefined:
                // Not specifying "sseEnabled: false" here because it would cause phony changes to existing stacks.
                return { sseSpecification: undefined };
            default:
                throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);
        }
    }
}
exports.Table = Table;
_a = JSII_RTTI_SYMBOL_1;
Table[_a] = { fqn: "@aws-cdk/aws-dynamodb.Table", version: "1.191.0" };
/**
 * Data types for attributes within a table
 *
 * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes
 */
var AttributeType;
(function (AttributeType) {
    /** Up to 400KiB of binary data (which must be encoded as base64 before sending to DynamoDB) */
    AttributeType["BINARY"] = "B";
    /** Numeric values made of up to 38 digits (positive, negative or zero) */
    AttributeType["NUMBER"] = "N";
    /** Up to 400KiB of UTF-8 encoded text */
    AttributeType["STRING"] = "S";
})(AttributeType = exports.AttributeType || (exports.AttributeType = {}));
/**
 * DynamoDB's Read/Write capacity modes.
 */
var BillingMode;
(function (BillingMode) {
    /**
     * Pay only for what you use. You don't configure Read/Write capacity units.
     */
    BillingMode["PAY_PER_REQUEST"] = "PAY_PER_REQUEST";
    /**
     * Explicitly specified Read/Write capacity units.
     */
    BillingMode["PROVISIONED"] = "PROVISIONED";
})(BillingMode = exports.BillingMode || (exports.BillingMode = {}));
/**
 * The set of attributes that are projected into the index
 *
 * @see https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Projection.html
 */
var ProjectionType;
(function (ProjectionType) {
    /** Only the index and primary keys are projected into the index. */
    ProjectionType["KEYS_ONLY"] = "KEYS_ONLY";
    /** Only the specified table attributes are projected into the index. The list of projected attributes is in `nonKeyAttributes`. */
    ProjectionType["INCLUDE"] = "INCLUDE";
    /** All of the table attributes are projected into the index. */
    ProjectionType["ALL"] = "ALL";
})(ProjectionType = exports.ProjectionType || (exports.ProjectionType = {}));
/**
 * When an item in the table is modified, StreamViewType determines what information
 * is written to the stream for this table.
 *
 * @see https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_StreamSpecification.html
 */
var StreamViewType;
(function (StreamViewType) {
    /** The entire item, as it appears after it was modified, is written to the stream. */
    StreamViewType["NEW_IMAGE"] = "NEW_IMAGE";
    /** The entire item, as it appeared before it was modified, is written to the stream. */
    StreamViewType["OLD_IMAGE"] = "OLD_IMAGE";
    /** Both the new and the old item images of the item are written to the stream. */
    StreamViewType["NEW_AND_OLD_IMAGES"] = "NEW_AND_OLD_IMAGES";
    /** Only the key attributes of the modified item are written to the stream. */
    StreamViewType["KEYS_ONLY"] = "KEYS_ONLY";
})(StreamViewType = exports.StreamViewType || (exports.StreamViewType = {}));
/**
 * DynamoDB's table class.
 *
 * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html
 */
var TableClass;
(function (TableClass) {
    /** Default table class for DynamoDB. */
    TableClass["STANDARD"] = "STANDARD";
    /** Table class for DynamoDB that reduces storage costs compared to existing DynamoDB Standard tables. */
    TableClass["STANDARD_INFREQUENT_ACCESS"] = "STANDARD_INFREQUENT_ACCESS";
})(TableClass = exports.TableClass || (exports.TableClass = {}));
/**
 * An inline policy that is logically bound to the source table of a DynamoDB Global Tables
 * "cluster". This is here to ensure permissions are removed as part of (and not before) the
 * CleanUp phase of a stack update, when a replica is removed (or the entire "cluster" gets
 * replaced).
 *
 * If statements are added directly to the handler roles (as opposed to in a separate inline
 * policy resource), new permissions are in effect before clean up happens, and so replicas that
 * need to be dropped can no longer be due to lack of permissions.
 */
class SourceTableAttachedPolicy extends core_2.Construct {
    constructor(sourceTable, role) {
        super(sourceTable, `SourceTableAttachedManagedPolicy-${core_1.Names.nodeUniqueId(role.node)}`);
        const policy = new iam.ManagedPolicy(this, 'Resource', {
            // A CF update of the description property of a managed policy requires
            // a replacement. Use the table name in the description to force a managed
            // policy replacement when the table name changes. This way we preserve permissions
            // to delete old replicas in case of a table replacement.
            description: `DynamoDB replication managed policy for table ${sourceTable.tableName}`,
            roles: [role],
        });
        this.policy = policy;
        this.grantPrincipal = new SourceTableAttachedPrincipal(role, policy);
    }
}
/**
 * An `IPrincipal` entity that can be used as the target of `grant` calls, used by the
 * `SourceTableAttachedPolicy` class so it can act as an `IGrantable`.
 */
class SourceTableAttachedPrincipal extends iam.PrincipalBase {
    constructor(role, policy) {
        super();
        this.role = role;
        this.policy = policy;
    }
    get policyFragment() {
        return this.role.policyFragment;
    }
    addToPrincipalPolicy(statement) {
        this.policy.addStatements(statement);
        return {
            policyDependable: this.policy,
            statementAdded: true,
        };
    }
    dedupeString() {
        return undefined;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.js","sourceRoot":"","sources":["table.ts"],"names":[],"mappings":"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","sourcesContent":["import * as appscaling from '@aws-cdk/aws-applicationautoscaling';\nimport * as cloudwatch from '@aws-cdk/aws-cloudwatch';\nimport * as iam from '@aws-cdk/aws-iam';\nimport * as kinesis from '@aws-cdk/aws-kinesis';\nimport * as kms from '@aws-cdk/aws-kms';\nimport {\n  ArnFormat,\n  Aws, CfnCondition, CfnCustomResource, CfnResource, CustomResource, Duration,\n  Fn, IResource, Lazy, Names, RemovalPolicy, Resource, Stack, Token,\n} from '@aws-cdk/core';\nimport { Construct } from 'constructs';\nimport { DynamoDBMetrics } from './dynamodb-canned-metrics.generated';\nimport { CfnTable, CfnTableProps } from './dynamodb.generated';\nimport * as perms from './perms';\nimport { ReplicaProvider } from './replica-provider';\nimport { EnableScalingProps, IScalableTableAttribute } from './scalable-attribute-api';\nimport { ScalableTableAttribute } from './scalable-table-attribute';\n\n// keep this import separate from other imports to reduce chance for merge conflicts with v2-main\n// eslint-disable-next-line no-duplicate-imports, import/order\nimport { Construct as CoreConstruct } from '@aws-cdk/core';\n\nconst HASH_KEY_TYPE = 'HASH';\nconst RANGE_KEY_TYPE = 'RANGE';\n\n// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-secondary-indexes\nconst MAX_LOCAL_SECONDARY_INDEX_COUNT = 5;\n\n/**\n * Options for configuring a system errors metric that considers multiple operations.\n */\nexport interface SystemErrorsForOperationsMetricOptions extends cloudwatch.MetricOptions {\n\n  /**\n   * The operations to apply the metric to.\n   *\n   * @default - All operations available by DynamoDB tables will be considered.\n   */\n  readonly operations?: Operation[];\n\n}\n\n/**\n * Supported DynamoDB table operations.\n */\nexport enum Operation {\n\n  /** GetItem */\n  GET_ITEM = 'GetItem',\n\n  /** BatchGetItem */\n  BATCH_GET_ITEM = 'BatchGetItem',\n\n  /** Scan */\n  SCAN = 'Scan',\n\n  /** Query */\n  QUERY = 'Query',\n\n  /** GetRecords */\n  GET_RECORDS = 'GetRecords',\n\n  /** PutItem */\n  PUT_ITEM = 'PutItem',\n\n  /** DeleteItem */\n  DELETE_ITEM = 'DeleteItem',\n\n  /** UpdateItem */\n  UPDATE_ITEM = 'UpdateItem',\n\n  /** BatchWriteItem */\n  BATCH_WRITE_ITEM = 'BatchWriteItem',\n\n  /** TransactWriteItems */\n  TRANSACT_WRITE_ITEMS = 'TransactWriteItems',\n\n  /** TransactGetItems */\n  TRANSACT_GET_ITEMS = 'TransactGetItems',\n\n  /** ExecuteTransaction */\n  EXECUTE_TRANSACTION = 'ExecuteTransaction',\n\n  /** BatchExecuteStatement */\n  BATCH_EXECUTE_STATEMENT = 'BatchExecuteStatement',\n\n  /** ExecuteStatement */\n  EXECUTE_STATEMENT = 'ExecuteStatement',\n\n}\n\n/**\n * Represents an attribute for describing the key schema for the table\n * and indexes.\n */\nexport interface Attribute {\n  /**\n   * The name of an attribute.\n   */\n  readonly name: string;\n\n  /**\n   * The data type of an attribute.\n   */\n  readonly type: AttributeType;\n}\n\n/**\n * What kind of server-side encryption to apply to this table.\n */\nexport enum TableEncryption {\n  /**\n   * Server-side KMS encryption with a master key owned by AWS.\n   */\n  DEFAULT = 'AWS_OWNED',\n\n  /**\n   * Server-side KMS encryption with a customer master key managed by customer.\n   * If `encryptionKey` is specified, this key will be used, otherwise, one will be defined.\n   *\n   * > **NOTE**: if `encryptionKey` is not specified and the `Table` construct creates\n   * > a KMS key for you, the key will be created with default permissions. If you are using\n   * > CDKv2, these permissions will be sufficient to enable the key for use with DynamoDB tables.\n   * > If you are using CDKv1, make sure the feature flag `@aws-cdk/aws-kms:defaultKeyPolicies`\n   * > is set to `true` in your `cdk.json`.\n   */\n  CUSTOMER_MANAGED = 'CUSTOMER_MANAGED',\n\n  /**\n   * Server-side KMS encryption with a master key managed by AWS.\n   */\n  AWS_MANAGED = 'AWS_MANAGED',\n}\n\n/**\n * Represents the table schema attributes.\n */\nexport interface SchemaOptions {\n  /**\n   * Partition key attribute definition.\n   */\n  readonly partitionKey: Attribute;\n\n  /**\n   * Sort key attribute definition.\n   *\n   * @default no sort key\n   */\n  readonly sortKey?: Attribute;\n}\n\n/**\n * Properties of a DynamoDB Table\n *\n * Use {@link TableProps} for all table properties\n */\nexport interface TableOptions extends SchemaOptions {\n  /**\n   * The read capacity for the table. Careful if you add Global Secondary Indexes, as\n   * those will share the table's provisioned throughput.\n   *\n   * Can only be provided if billingMode is Provisioned.\n   *\n   * @default 5\n   */\n  readonly readCapacity?: number;\n  /**\n   * The write capacity for the table. Careful if you add Global Secondary Indexes, as\n   * those will share the table's provisioned throughput.\n   *\n   * Can only be provided if billingMode is Provisioned.\n   *\n   * @default 5\n   */\n  readonly writeCapacity?: number;\n\n  /**\n   * Specify how you are charged for read and write throughput and how you manage capacity.\n   *\n   * @default PROVISIONED if `replicationRegions` is not specified, PAY_PER_REQUEST otherwise\n   */\n  readonly billingMode?: BillingMode;\n\n  /**\n   * Whether point-in-time recovery is enabled.\n   * @default - point-in-time recovery is disabled\n   */\n  readonly pointInTimeRecovery?: boolean;\n\n  /**\n   * Whether server-side encryption with an AWS managed customer master key is enabled.\n   *\n   * This property cannot be set if `encryption` and/or `encryptionKey` is set.\n   *\n   * @default - server-side encryption is enabled with an AWS owned customer master key\n   *\n   * @deprecated This property is deprecated. In order to obtain the same behavior as\n   * enabling this, set the `encryption` property to `TableEncryption.AWS_MANAGED` instead.\n   */\n  readonly serverSideEncryption?: boolean;\n\n  /**\n   * Specify the table class.\n   * @default STANDARD\n   */\n  readonly tableClass?: TableClass;\n\n  /**\n   * Whether server-side encryption with an AWS managed customer master key is enabled.\n   *\n   * This property cannot be set if `serverSideEncryption` is set.\n   *\n   * > **NOTE**: if you set this to `CUSTOMER_MANAGED` and `encryptionKey` is not\n   * > specified, the key that the Tablet generates for you will be created with\n   * > default permissions. If you are using CDKv2, these permissions will be\n   * > sufficient to enable the key for use with DynamoDB tables.  If you are\n   * > using CDKv1, make sure the feature flag\n   * > `@aws-cdk/aws-kms:defaultKeyPolicies` is set to `true` in your `cdk.json`.\n   *\n   * @default - server-side encryption is enabled with an AWS owned customer master key\n   */\n  readonly encryption?: TableEncryption;\n\n  /**\n   * External KMS key to use for table encryption.\n   *\n   * This property can only be set if `encryption` is set to `TableEncryption.CUSTOMER_MANAGED`.\n   *\n   * @default - If `encryption` is set to `TableEncryption.CUSTOMER_MANAGED` and this\n   * property is undefined, a new KMS key will be created and associated with this table.\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * The name of TTL attribute.\n   * @default - TTL is disabled\n   */\n  readonly timeToLiveAttribute?: string;\n\n  /**\n   * When an item in the table is modified, StreamViewType determines what information\n   * is written to the stream for this table.\n   *\n   * @default - streams are disabled unless `replicationRegions` is specified\n   */\n  readonly stream?: StreamViewType;\n\n  /**\n   * The removal policy to apply to the DynamoDB Table.\n   *\n   * @default RemovalPolicy.RETAIN\n   */\n  readonly removalPolicy?: RemovalPolicy;\n\n  /**\n   * Regions where replica tables will be created\n   *\n   * @default - no replica tables are created\n   */\n  readonly replicationRegions?: string[];\n\n  /**\n   * The timeout for a table replication operation in a single region.\n   *\n   * @default Duration.minutes(30)\n   */\n  readonly replicationTimeout?: Duration;\n\n  /**\n   * Indicates whether CloudFormation stack waits for replication to finish.\n   * If set to false, the CloudFormation resource will mark the resource as\n   * created and replication will be completed asynchronously. This property is\n   * ignored if replicationRegions property is not set.\n   *\n   * DO NOT UNSET this property if adding/removing multiple replicationRegions\n   * in one deployment, as CloudFormation only supports one region replication\n   * at a time. CDK overcomes this limitation by waiting for replication to\n   * finish before starting new replicationRegion.\n   *\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-dynamodb-globaltable.html#cfn-dynamodb-globaltable-replicas\n   * @default true\n   */\n  readonly waitForReplicationToFinish?: boolean;\n\n  /**\n   * Whether CloudWatch contributor insights is enabled.\n   *\n   * @default false\n   */\n  readonly contributorInsightsEnabled?: boolean;\n}\n\n/**\n * Properties for a DynamoDB Table\n */\nexport interface TableProps extends TableOptions {\n  /**\n   * Enforces a particular physical table name.\n   * @default <generated>\n   */\n  readonly tableName?: string;\n\n  /**\n   * Kinesis Data Stream to capture item-level changes for the table.\n   *\n   * @default - no Kinesis Data Stream\n   */\n  readonly kinesisStream?: kinesis.IStream;\n}\n\n/**\n * Properties for a secondary index\n */\nexport interface SecondaryIndexProps {\n  /**\n   * The name of the secondary index.\n   */\n  readonly indexName: string;\n\n  /**\n   * The set of attributes that are projected into the secondary index.\n   * @default ALL\n   */\n  readonly projectionType?: ProjectionType;\n\n  /**\n   * The non-key attributes that are projected into the secondary index.\n   * @default - No additional attributes\n   */\n  readonly nonKeyAttributes?: string[];\n}\n\n/**\n * Properties for a global secondary index\n */\nexport interface GlobalSecondaryIndexProps extends SecondaryIndexProps, SchemaOptions {\n  /**\n   * The read capacity for the global secondary index.\n   *\n   * Can only be provided if table billingMode is Provisioned or undefined.\n   *\n   * @default 5\n   */\n  readonly readCapacity?: number;\n\n  /**\n   * The write capacity for the global secondary index.\n   *\n   * Can only be provided if table billingMode is Provisioned or undefined.\n   *\n   * @default 5\n   */\n  readonly writeCapacity?: number;\n}\n\n/**\n * Properties for a local secondary index\n */\nexport interface LocalSecondaryIndexProps extends SecondaryIndexProps {\n  /**\n   * The attribute of a sort key for the local secondary index.\n   */\n  readonly sortKey: Attribute;\n}\n\n/**\n * An interface that represents a DynamoDB Table - either created with the CDK, or an existing one.\n */\nexport interface ITable extends IResource {\n  /**\n   * Arn of the dynamodb table.\n   *\n   * @attribute\n   */\n  readonly tableArn: string;\n\n  /**\n   * Table name of the dynamodb table.\n   *\n   * @attribute\n   */\n  readonly tableName: string;\n\n  /**\n   * ARN of the table's stream, if there is one.\n   *\n   * @attribute\n   */\n  readonly tableStreamArn?: string;\n\n  /**\n   *\n   * Optional KMS encryption key associated with this table.\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * Adds an IAM policy statement associated with this table to an IAM\n   * principal's policy.\n   *\n   * If `encryptionKey` is present, appropriate grants to the key needs to be added\n   * separately using the `table.encryptionKey.grant*` methods.\n   *\n   * @param grantee The principal (no-op if undefined)\n   * @param actions The set of actions to allow (i.e. \"dynamodb:PutItem\", \"dynamodb:GetItem\", ...)\n   */\n  grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Adds an IAM policy statement associated with this table's stream to an\n   * IAM principal's policy.\n   *\n   * If `encryptionKey` is present, appropriate grants to the key needs to be added\n   * separately using the `table.encryptionKey.grant*` methods.\n   *\n   * @param grantee The principal (no-op if undefined)\n   * @param actions The set of actions to allow (i.e. \"dynamodb:DescribeStream\", \"dynamodb:GetRecords\", ...)\n   */\n  grantStream(grantee: iam.IGrantable, ...actions: string[]): iam.Grant;\n\n  /**\n   * Permits an IAM principal all data read operations from this table:\n   * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  grantReadData(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Permits an IAM Principal to list streams attached to current dynamodb table.\n   *\n   * @param grantee The principal (no-op if undefined)\n   */\n  grantTableListStreams(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Permits an IAM principal all stream data read operations for this\n   * table's stream:\n   * DescribeStream, GetRecords, GetShardIterator, ListStreams.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  grantStreamRead(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Permits an IAM principal all data write operations to this table:\n   * BatchWriteItem, PutItem, UpdateItem, DeleteItem.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  grantWriteData(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Permits an IAM principal to all data read/write operations to this table.\n   * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan,\n   * BatchWriteItem, PutItem, UpdateItem, DeleteItem\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  grantReadWriteData(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Permits all DynamoDB operations (\"dynamodb:*\") to an IAM principal.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  grantFullAccess(grantee: iam.IGrantable): iam.Grant;\n\n  /**\n   * Metric for the number of Errors executing all Lambdas\n   */\n  metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the consumed read capacity units\n   *\n   * @param props properties of a metric\n   */\n  metricConsumedReadCapacityUnits(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the consumed write capacity units\n   *\n   * @param props properties of a metric\n   */\n  metricConsumedWriteCapacityUnits(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the system errors\n   *\n   * @param props properties of a metric\n   *\n   * @deprecated use `metricSystemErrorsForOperations`\n   */\n  metricSystemErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the system errors this table\n   *\n   * @param props properties of a metric\n   *\n   */\n  metricSystemErrorsForOperations(props?: SystemErrorsForOperationsMetricOptions): cloudwatch.IMetric;\n\n  /**\n   * Metric for the user errors\n   *\n   * @param props properties of a metric\n   */\n  metricUserErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the conditional check failed requests\n   *\n   * @param props properties of a metric\n   */\n  metricConditionalCheckFailedRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for throttled requests\n   *\n   * @param props properties of a metric\n   *\n   */\n  metricThrottledRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the successful request latency\n   *\n   * @param props properties of a metric\n   *\n   */\n  metricSuccessfulRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n}\n\n/**\n * Reference to a dynamodb table.\n */\nexport interface TableAttributes {\n  /**\n   * The ARN of the dynamodb table.\n   * One of this, or {@link tableName}, is required.\n   *\n   * @default - no table arn\n   */\n  readonly tableArn?: string;\n\n  /**\n   * The table name of the dynamodb table.\n   * One of this, or {@link tableArn}, is required.\n   *\n   * @default - no table name\n   */\n  readonly tableName?: string;\n\n  /**\n   * The ARN of the table's stream.\n   *\n   * @default - no table stream\n   */\n  readonly tableStreamArn?: string;\n\n  /**\n   * KMS encryption key, if this table uses a customer-managed encryption key.\n   *\n   * @default - no key\n   */\n  readonly encryptionKey?: kms.IKey;\n\n  /**\n   * The name of the global indexes set for this Table.\n   * Note that you need to set either this property,\n   * or {@link localIndexes},\n   * if you want methods like grantReadData()\n   * to grant permissions for indexes as well as the table itself.\n   *\n   * @default - no global indexes\n   */\n  readonly globalIndexes?: string[];\n\n  /**\n   * The name of the local indexes set for this Table.\n   * Note that you need to set either this property,\n   * or {@link globalIndexes},\n   * if you want methods like grantReadData()\n   * to grant permissions for indexes as well as the table itself.\n   *\n   * @default - no local indexes\n   */\n  readonly localIndexes?: string[];\n}\n\nabstract class TableBase extends Resource implements ITable {\n  /**\n   * @attribute\n   */\n  public abstract readonly tableArn: string;\n\n  /**\n   * @attribute\n   */\n  public abstract readonly tableName: string;\n\n  /**\n   * @attribute\n   */\n  public abstract readonly tableStreamArn?: string;\n\n  /**\n   * KMS encryption key, if this table uses a customer-managed encryption key.\n   */\n  public abstract readonly encryptionKey?: kms.IKey;\n\n  protected readonly regionalArns = new Array<string>();\n\n  /**\n   * Adds an IAM policy statement associated with this table to an IAM\n   * principal's policy.\n   *\n   * If `encryptionKey` is present, appropriate grants to the key needs to be added\n   * separately using the `table.encryptionKey.grant*` methods.\n   *\n   * @param grantee The principal (no-op if undefined)\n   * @param actions The set of actions to allow (i.e. \"dynamodb:PutItem\", \"dynamodb:GetItem\", ...)\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [\n        this.tableArn,\n        Lazy.string({ produce: () => this.hasIndex ? `${this.tableArn}/index/*` : Aws.NO_VALUE }),\n        ...this.regionalArns,\n        ...this.regionalArns.map(arn => Lazy.string({\n          produce: () => this.hasIndex ? `${arn}/index/*` : Aws.NO_VALUE,\n        })),\n      ],\n      scope: this,\n    });\n  }\n\n  /**\n   * Adds an IAM policy statement associated with this table's stream to an\n   * IAM principal's policy.\n   *\n   * If `encryptionKey` is present, appropriate grants to the key needs to be added\n   * separately using the `table.encryptionKey.grant*` methods.\n   *\n   * @param grantee The principal (no-op if undefined)\n   * @param actions The set of actions to allow (i.e. \"dynamodb:DescribeStream\", \"dynamodb:GetRecords\", ...)\n   */\n  public grantStream(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    if (!this.tableStreamArn) {\n      throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);\n    }\n\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.tableStreamArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Permits an IAM principal all data read operations from this table:\n   * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan, DescribeTable.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantReadData(grantee: iam.IGrantable): iam.Grant {\n    const tableActions = perms.READ_DATA_ACTIONS.concat(perms.DESCRIBE_TABLE);\n    return this.combinedGrant(grantee, { keyActions: perms.KEY_READ_ACTIONS, tableActions });\n  }\n\n  /**\n   * Permits an IAM Principal to list streams attached to current dynamodb table.\n   *\n   * @param grantee The principal (no-op if undefined)\n   */\n  public grantTableListStreams(grantee: iam.IGrantable): iam.Grant {\n    if (!this.tableStreamArn) {\n      throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);\n    }\n\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: ['dynamodb:ListStreams'],\n      resourceArns: ['*'],\n    });\n  }\n\n  /**\n   * Permits an IAM principal all stream data read operations for this\n   * table's stream:\n   * DescribeStream, GetRecords, GetShardIterator, ListStreams.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantStreamRead(grantee: iam.IGrantable): iam.Grant {\n    this.grantTableListStreams(grantee);\n    return this.combinedGrant(grantee, { keyActions: perms.KEY_READ_ACTIONS, streamActions: perms.READ_STREAM_DATA_ACTIONS });\n  }\n\n  /**\n   * Permits an IAM principal all data write operations to this table:\n   * BatchWriteItem, PutItem, UpdateItem, DeleteItem, DescribeTable.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantWriteData(grantee: iam.IGrantable): iam.Grant {\n    const tableActions = perms.WRITE_DATA_ACTIONS.concat(perms.DESCRIBE_TABLE);\n    const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);\n    return this.combinedGrant(grantee, { keyActions, tableActions });\n  }\n\n  /**\n   * Permits an IAM principal to all data read/write operations to this table.\n   * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan,\n   * BatchWriteItem, PutItem, UpdateItem, DeleteItem, DescribeTable\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantReadWriteData(grantee: iam.IGrantable): iam.Grant {\n    const tableActions = perms.READ_DATA_ACTIONS.concat(perms.WRITE_DATA_ACTIONS).concat(perms.DESCRIBE_TABLE);\n    const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);\n    return this.combinedGrant(grantee, { keyActions, tableActions });\n  }\n\n  /**\n   * Permits all DynamoDB operations (\"dynamodb:*\") to an IAM principal.\n   *\n   * Appropriate grants will also be added to the customer-managed KMS key\n   * if one was configured.\n   *\n   * @param grantee The principal to grant access to\n   */\n  public grantFullAccess(grantee: iam.IGrantable) {\n    const keyActions = perms.KEY_READ_ACTIONS.concat(perms.KEY_WRITE_ACTIONS);\n    return this.combinedGrant(grantee, { keyActions, tableActions: ['dynamodb:*'] });\n  }\n\n  /**\n   * Return the given named metric for this Table\n   *\n   * By default, the metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: 'AWS/DynamoDB',\n      metricName,\n      dimensionsMap: {\n        TableName: this.tableName,\n      },\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the consumed read capacity units this table\n   *\n   * By default, the metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metricConsumedReadCapacityUnits(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.cannedMetric(DynamoDBMetrics.consumedReadCapacityUnitsSum, props);\n  }\n\n  /**\n   * Metric for the consumed write capacity units this table\n   *\n   * By default, the metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metricConsumedWriteCapacityUnits(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.cannedMetric(DynamoDBMetrics.consumedWriteCapacityUnitsSum, props);\n  }\n\n  /**\n   * Metric for the system errors this table\n   *\n   * @deprecated use `metricSystemErrorsForOperations`.\n   */\n  public metricSystemErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    if (!props?.dimensions?.Operation && !props?.dimensionsMap?.Operation) {\n      // 'Operation' must be passed because its an operational metric.\n      throw new Error(\"'Operation' dimension must be passed for the 'SystemErrors' metric.\");\n    }\n\n    const dimensionsMap = {\n      TableName: this.tableName,\n      ...props?.dimensions ?? {},\n      ...props?.dimensionsMap ?? {},\n    };\n\n    return this.metric('SystemErrors', { statistic: 'sum', ...props, dimensionsMap });\n  }\n\n  /**\n   * Metric for the user errors. Note that this metric reports user errors across all\n   * the tables in the account and region the table resides in.\n   *\n   * By default, the metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metricUserErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    if (props?.dimensions) {\n      throw new Error(\"'dimensions' is not supported for the 'UserErrors' metric\");\n    }\n\n    // overriding 'dimensions' here because this metric is an account metric.\n    // see 'UserErrors' in https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/metrics-dimensions.html\n    return this.metric('UserErrors', { statistic: 'sum', ...props, dimensionsMap: {} });\n  }\n\n  /**\n   * Metric for the conditional check failed requests this table\n   *\n   * By default, the metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metricConditionalCheckFailedRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('ConditionalCheckFailedRequests', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * How many requests are throttled on this table\n   *\n   * Default: sum over 5 minutes\n   *\n   * @deprecated Do not use this function. It returns an invalid metric. Use `metricThrottledRequestsForOperation` instead.\n   */\n  public metricThrottledRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metric('ThrottledRequests', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * How many requests are throttled on this table, for the given operation\n   *\n   * Default: sum over 5 minutes\n   */\n  public metricThrottledRequestsForOperation(operation: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...DynamoDBMetrics.throttledRequestsSum({ Operation: operation, TableName: this.tableName }),\n      ...props,\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the successful request latency this table.\n   *\n   * By default, the metric will be calculated as an average over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metricSuccessfulRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    if (!props?.dimensions?.Operation && !props?.dimensionsMap?.Operation) {\n      throw new Error(\"'Operation' dimension must be passed for the 'SuccessfulRequestLatency' metric.\");\n    }\n\n    const dimensionsMap = {\n      TableName: this.tableName,\n      Operation: props.dimensionsMap?.Operation ?? props.dimensions?.Operation,\n    };\n\n    return new cloudwatch.Metric({\n      ...DynamoDBMetrics.successfulRequestLatencyAverage(dimensionsMap),\n      ...props,\n      dimensionsMap,\n    }).attachTo(this);\n  }\n\n  /**\n   * Metric for the system errors this table.\n   *\n   * This will sum errors across all possible operations.\n   * Note that by default, each individual metric will be calculated as a sum over a period of 5 minutes.\n   * You can customize this by using the `statistic` and `period` properties.\n   */\n  public metricSystemErrorsForOperations(props?: SystemErrorsForOperationsMetricOptions): cloudwatch.IMetric {\n\n    if (props?.dimensions?.Operation) {\n      throw new Error(\"The Operation dimension is not supported. Use the 'operations' property.\");\n    }\n\n    const operations = props?.operations ?? Object.values(Operation);\n\n    const values = this.createMetricsForOperations('SystemErrors', operations, { statistic: 'sum', ...props });\n\n    const sum = new cloudwatch.MathExpression({\n      expression: `${Object.keys(values).join(' + ')}`,\n      usingMetrics: { ...values },\n      color: props?.color,\n      label: 'Sum of errors across all operations',\n      period: props?.period,\n    });\n\n    return sum;\n  }\n\n  /**\n   * Create a map of metrics that can be used in a math expression.\n   *\n   * Using the return value of this function as the `usingMetrics` property in `cloudwatch.MathExpression` allows you to\n   * use the keys of this map as metric names inside you expression.\n   *\n   * @param metricName The metric name.\n   * @param operations The list of operations to create metrics for.\n   * @param props Properties for the individual metrics.\n   * @param metricNameMapper Mapper function to allow controlling the individual metric name per operation.\n   */\n  private createMetricsForOperations(metricName: string, operations: Operation[],\n    props?: cloudwatch.MetricOptions, metricNameMapper?: (op: Operation) => string): Record<string, cloudwatch.IMetric> {\n\n    const metrics: Record<string, cloudwatch.IMetric> = {};\n\n    const mapper = metricNameMapper ?? (op => op.toLowerCase());\n\n    if (props?.dimensions?.Operation) {\n      throw new Error('Invalid properties. Operation dimension is not supported when calculating operational metrics');\n    }\n\n    for (const operation of operations) {\n\n      const metric = this.metric(metricName, {\n        ...props,\n        dimensionsMap: {\n          TableName: this.tableName,\n          Operation: operation,\n          ...props?.dimensions,\n        },\n      });\n\n      const operationMetricName = mapper(operation);\n      const firstChar = operationMetricName.charAt(0);\n\n      if (firstChar === firstChar.toUpperCase()) {\n        // https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/using-metric-math.html#metric-math-syntax\n        throw new Error(`Mapper generated an illegal operation metric name: ${operationMetricName}. Must start with a lowercase letter`);\n      }\n\n      metrics[operationMetricName] = metric;\n    }\n\n    return metrics;\n  }\n\n  protected abstract get hasIndex(): boolean;\n\n  /**\n   * Adds an IAM policy statement associated with this table to an IAM\n   * principal's policy.\n   * @param grantee The principal (no-op if undefined)\n   * @param opts Options for keyActions, tableActions and streamActions\n   */\n  private combinedGrant(\n    grantee: iam.IGrantable,\n    opts: { keyActions?: string[], tableActions?: string[], streamActions?: string[] },\n  ): iam.Grant {\n    if (opts.tableActions) {\n      const resources = [this.tableArn,\n        Lazy.string({ produce: () => this.hasIndex ? `${this.tableArn}/index/*` : Aws.NO_VALUE }),\n        ...this.regionalArns,\n        ...this.regionalArns.map(arn => Lazy.string({\n          produce: () => this.hasIndex ? `${arn}/index/*` : Aws.NO_VALUE,\n        }))];\n      const ret = iam.Grant.addToPrincipal({\n        grantee,\n        actions: opts.tableActions,\n        resourceArns: resources,\n        scope: this,\n      });\n      if (this.encryptionKey && opts.keyActions) {\n        this.encryptionKey.grant(grantee, ...opts.keyActions);\n      }\n      return ret;\n    }\n    if (opts.streamActions) {\n      if (!this.tableStreamArn) {\n        throw new Error(`DynamoDB Streams must be enabled on the table ${this.node.path}`);\n      }\n      const resources = [this.tableStreamArn];\n      const ret = iam.Grant.addToPrincipal({\n        grantee,\n        actions: opts.streamActions,\n        resourceArns: resources,\n        scope: this,\n      });\n      return ret;\n    }\n    throw new Error(`Unexpected 'action', ${opts.tableActions || opts.streamActions}`);\n  }\n\n  private cannedMetric(\n    fn: (dims: { TableName: string }) => cloudwatch.MetricProps,\n    props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      ...fn({ TableName: this.tableName }),\n      ...props,\n    }).attachTo(this);\n  }\n}\n\n/**\n * Provides a DynamoDB table.\n */\nexport class Table extends TableBase {\n  /**\n   * Permits an IAM Principal to list all DynamoDB Streams.\n   * @deprecated Use {@link #grantTableListStreams} for more granular permission\n   * @param grantee The principal (no-op if undefined)\n   */\n  public static grantListStreams(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions: ['dynamodb:ListStreams'],\n      resourceArns: ['*'],\n    });\n  }\n\n  /**\n   * Creates a Table construct that represents an external table via table name.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param tableName The table's name.\n   */\n  public static fromTableName(scope: Construct, id: string, tableName: string): ITable {\n    return Table.fromTableAttributes(scope, id, { tableName });\n  }\n\n  /**\n   * Creates a Table construct that represents an external table via table arn.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param tableArn The table's ARN.\n   */\n  public static fromTableArn(scope: Construct, id: string, tableArn: string): ITable {\n    return Table.fromTableAttributes(scope, id, { tableArn });\n  }\n\n  /**\n   * Creates a Table construct that represents an external table.\n   *\n   * @param scope The parent creating construct (usually `this`).\n   * @param id The construct's name.\n   * @param attrs A `TableAttributes` object.\n   */\n  public static fromTableAttributes(scope: Construct, id: string, attrs: TableAttributes): ITable {\n\n    class Import extends TableBase {\n\n      public readonly tableName: string;\n      public readonly tableArn: string;\n      public readonly tableStreamArn?: string;\n      public readonly encryptionKey?: kms.IKey;\n      protected readonly hasIndex = (attrs.globalIndexes ?? []).length > 0 ||\n        (attrs.localIndexes ?? []).length > 0;\n\n      constructor(_tableArn: string, tableName: string, tableStreamArn?: string) {\n        super(scope, id);\n        this.tableArn = _tableArn;\n        this.tableName = tableName;\n        this.tableStreamArn = tableStreamArn;\n        this.encryptionKey = attrs.encryptionKey;\n      }\n    }\n\n    let name: string;\n    let arn: string;\n    const stack = Stack.of(scope);\n    if (!attrs.tableName) {\n      if (!attrs.tableArn) { throw new Error('One of tableName or tableArn is required!'); }\n\n      arn = attrs.tableArn;\n      const maybeTableName = stack.splitArn(attrs.tableArn, ArnFormat.SLASH_RESOURCE_NAME).resourceName;\n      if (!maybeTableName) { throw new Error('ARN for DynamoDB table must be in the form: ...'); }\n      name = maybeTableName;\n    } else {\n      if (attrs.tableArn) { throw new Error('Only one of tableArn or tableName can be provided'); }\n      name = attrs.tableName;\n      arn = stack.formatArn({\n        service: 'dynamodb',\n        resource: 'table',\n        resourceName: attrs.tableName,\n      });\n    }\n\n    return new Import(arn, name, attrs.tableStreamArn);\n  }\n\n  public readonly encryptionKey?: kms.IKey;\n\n  /**\n   * @attribute\n   */\n  public readonly tableArn: string;\n\n  /**\n   * @attribute\n   */\n  public readonly tableName: string;\n\n  /**\n   * @attribute\n   */\n  public readonly tableStreamArn: string | undefined;\n\n  private readonly table: CfnTable;\n\n  private readonly keySchema = new Array<CfnTable.KeySchemaProperty>();\n  private readonly attributeDefinitions = new Array<CfnTable.AttributeDefinitionProperty>();\n  private readonly globalSecondaryIndexes = new Array<CfnTable.GlobalSecondaryIndexProperty>();\n  private readonly localSecondaryIndexes = new Array<CfnTable.LocalSecondaryIndexProperty>();\n\n  private readonly secondaryIndexSchemas = new Map<string, SchemaOptions>();\n  private readonly nonKeyAttributes = new Set<string>();\n\n  private readonly tablePartitionKey: Attribute;\n  private readonly tableSortKey?: Attribute;\n\n  private readonly billingMode: BillingMode;\n  private readonly tableScaling: ScalableAttributePair = {};\n  private readonly indexScaling = new Map<string, ScalableAttributePair>();\n  private readonly scalingRole: iam.IRole;\n\n  private readonly globalReplicaCustomResources = new Array<CustomResource>();\n\n  constructor(scope: Construct, id: string, props: TableProps) {\n    super(scope, id, {\n      physicalName: props.tableName,\n    });\n\n    const { sseSpecification, encryptionKey } = this.parseEncryption(props);\n\n    let streamSpecification: CfnTable.StreamSpecificationProperty | undefined;\n    if (props.replicationRegions) {\n      if (props.stream && props.stream !== StreamViewType.NEW_AND_OLD_IMAGES) {\n        throw new Error('`stream` must be set to `NEW_AND_OLD_IMAGES` when specifying `replicationRegions`');\n      }\n      streamSpecification = { streamViewType: StreamViewType.NEW_AND_OLD_IMAGES };\n\n      this.billingMode = props.billingMode ?? BillingMode.PAY_PER_REQUEST;\n    } else {\n      this.billingMode = props.billingMode ?? BillingMode.PROVISIONED;\n      if (props.stream) {\n        streamSpecification = { streamViewType: props.stream };\n      }\n    }\n    this.validateProvisioning(props);\n\n    this.table = new CfnTable(this, 'Resource', {\n      tableName: this.physicalName,\n      keySchema: this.keySchema,\n      attributeDefinitions: this.attributeDefinitions,\n      globalSecondaryIndexes: Lazy.any({ produce: () => this.globalSecondaryIndexes }, { omitEmptyArray: true }),\n      localSecondaryIndexes: Lazy.any({ produce: () => this.localSecondaryIndexes }, { omitEmptyArray: true }),\n      pointInTimeRecoverySpecification: props.pointInTimeRecovery != null ? { pointInTimeRecoveryEnabled: props.pointInTimeRecovery } : undefined,\n      billingMode: this.billingMode === BillingMode.PAY_PER_REQUEST ? this.billingMode : undefined,\n      provisionedThroughput: this.billingMode === BillingMode.PAY_PER_REQUEST ? undefined : {\n        readCapacityUnits: props.readCapacity || 5,\n        writeCapacityUnits: props.writeCapacity || 5,\n      },\n      sseSpecification,\n      streamSpecification,\n      tableClass: props.tableClass,\n      timeToLiveSpecification: props.timeToLiveAttribute ? { attributeName: props.timeToLiveAttribute, enabled: true } : undefined,\n      contributorInsightsSpecification: props.contributorInsightsEnabled !== undefined ? { enabled: props.contributorInsightsEnabled } : undefined,\n      kinesisStreamSpecification: props.kinesisStream ? { streamArn: props.kinesisStream.streamArn } : undefined,\n    });\n    this.table.applyRemovalPolicy(props.removalPolicy);\n\n    this.encryptionKey = encryptionKey;\n\n    this.tableArn = this.getResourceArnAttribute(this.table.attrArn, {\n      service: 'dynamodb',\n      resource: 'table',\n      resourceName: this.physicalName,\n    });\n    this.tableName = this.getResourceNameAttribute(this.table.ref);\n\n    if (props.tableName) { this.node.addMetadata('aws:cdk:hasPhysicalName', this.tableName); }\n\n    this.tableStreamArn = streamSpecification ? this.table.attrStreamArn : undefined;\n\n    this.scalingRole = this.makeScalingRole();\n\n    this.addKey(props.partitionKey, HASH_KEY_TYPE);\n    this.tablePartitionKey = props.partitionKey;\n\n    if (props.sortKey) {\n      this.addKey(props.sortKey, RANGE_KEY_TYPE);\n      this.tableSortKey = props.sortKey;\n    }\n\n    if (props.replicationRegions && props.replicationRegions.length > 0) {\n      this.createReplicaTables(props.replicationRegions, props.replicationTimeout, props.waitForReplicationToFinish);\n    }\n  }\n\n  /**\n   * Add a global secondary index of table.\n   *\n   * @param props the property of global secondary index\n   */\n  public addGlobalSecondaryIndex(props: GlobalSecondaryIndexProps) {\n    this.validateProvisioning(props);\n    this.validateIndexName(props.indexName);\n\n    // build key schema and projection for index\n    const gsiKeySchema = this.buildIndexKeySchema(props.partitionKey, props.sortKey);\n    const gsiProjection = this.buildIndexProjection(props);\n\n    this.globalSecondaryIndexes.push({\n      indexName: props.indexName,\n      keySchema: gsiKeySchema,\n      projection: gsiProjection,\n      provisionedThroughput: this.billingMode === BillingMode.PAY_PER_REQUEST ? undefined : {\n        readCapacityUnits: props.readCapacity || 5,\n        writeCapacityUnits: props.writeCapacity || 5,\n      },\n    });\n\n    this.secondaryIndexSchemas.set(props.indexName, {\n      partitionKey: props.partitionKey,\n      sortKey: props.sortKey,\n    });\n\n    this.indexScaling.set(props.indexName, {});\n  }\n\n  /**\n   * Add a local secondary index of table.\n   *\n   * @param props the property of local secondary index\n   */\n  public addLocalSecondaryIndex(props: LocalSecondaryIndexProps) {\n    // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-secondary-indexes\n    if (this.localSecondaryIndexes.length >= MAX_LOCAL_SECONDARY_INDEX_COUNT) {\n      throw new RangeError(`a maximum number of local secondary index per table is ${MAX_LOCAL_SECONDARY_INDEX_COUNT}`);\n    }\n\n    this.validateIndexName(props.indexName);\n\n    // build key schema and projection for index\n    const lsiKeySchema = this.buildIndexKeySchema(this.tablePartitionKey, props.sortKey);\n    const lsiProjection = this.buildIndexProjection(props);\n\n    this.localSecondaryIndexes.push({\n      indexName: props.indexName,\n      keySchema: lsiKeySchema,\n      projection: lsiProjection,\n    });\n\n    this.secondaryIndexSchemas.set(props.indexName, {\n      partitionKey: this.tablePartitionKey,\n      sortKey: props.sortKey,\n    });\n  }\n\n  /**\n   * Enable read capacity scaling for this table\n   *\n   * @returns An object to configure additional AutoScaling settings\n   */\n  public autoScaleReadCapacity(props: EnableScalingProps): IScalableTableAttribute {\n    if (this.tableScaling.scalableReadAttribute) {\n      throw new Error('Read AutoScaling already enabled for this table');\n    }\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');\n    }\n\n    return this.tableScaling.scalableReadAttribute = new ScalableTableAttribute(this, 'ReadScaling', {\n      serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n      resourceId: `table/${this.tableName}`,\n      dimension: 'dynamodb:table:ReadCapacityUnits',\n      role: this.scalingRole,\n      ...props,\n    });\n  }\n\n  /**\n   * Enable write capacity scaling for this table\n   *\n   * @returns An object to configure additional AutoScaling settings for this attribute\n   */\n  public autoScaleWriteCapacity(props: EnableScalingProps): IScalableTableAttribute {\n    if (this.tableScaling.scalableWriteAttribute) {\n      throw new Error('Write AutoScaling already enabled for this table');\n    }\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');\n    }\n\n    this.tableScaling.scalableWriteAttribute = new ScalableTableAttribute(this, 'WriteScaling', {\n      serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n      resourceId: `table/${this.tableName}`,\n      dimension: 'dynamodb:table:WriteCapacityUnits',\n      role: this.scalingRole,\n      ...props,\n    });\n    for (const globalReplicaCustomResource of this.globalReplicaCustomResources) {\n      globalReplicaCustomResource.node.addDependency(this.tableScaling.scalableWriteAttribute);\n    }\n    return this.tableScaling.scalableWriteAttribute;\n  }\n\n  /**\n   * Enable read capacity scaling for the given GSI\n   *\n   * @returns An object to configure additional AutoScaling settings for this attribute\n   */\n  public autoScaleGlobalSecondaryIndexReadCapacity(indexName: string, props: EnableScalingProps): IScalableTableAttribute {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');\n    }\n    const attributePair = this.indexScaling.get(indexName);\n    if (!attributePair) {\n      throw new Error(`No global secondary index with name ${indexName}`);\n    }\n    if (attributePair.scalableReadAttribute) {\n      throw new Error('Read AutoScaling already enabled for this index');\n    }\n\n    return attributePair.scalableReadAttribute = new ScalableTableAttribute(this, `${indexName}ReadScaling`, {\n      serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n      resourceId: `table/${this.tableName}/index/${indexName}`,\n      dimension: 'dynamodb:index:ReadCapacityUnits',\n      role: this.scalingRole,\n      ...props,\n    });\n  }\n\n  /**\n   * Enable write capacity scaling for the given GSI\n   *\n   * @returns An object to configure additional AutoScaling settings for this attribute\n   */\n  public autoScaleGlobalSecondaryIndexWriteCapacity(indexName: string, props: EnableScalingProps): IScalableTableAttribute {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      throw new Error('AutoScaling is not available for tables with PAY_PER_REQUEST billing mode');\n    }\n    const attributePair = this.indexScaling.get(indexName);\n    if (!attributePair) {\n      throw new Error(`No global secondary index with name ${indexName}`);\n    }\n    if (attributePair.scalableWriteAttribute) {\n      throw new Error('Write AutoScaling already enabled for this index');\n    }\n\n    return attributePair.scalableWriteAttribute = new ScalableTableAttribute(this, `${indexName}WriteScaling`, {\n      serviceNamespace: appscaling.ServiceNamespace.DYNAMODB,\n      resourceId: `table/${this.tableName}/index/${indexName}`,\n      dimension: 'dynamodb:index:WriteCapacityUnits',\n      role: this.scalingRole,\n      ...props,\n    });\n  }\n\n  /**\n   * Get schema attributes of table or index.\n   *\n   * @returns Schema of table or index.\n   */\n  public schema(indexName?: string): SchemaOptions {\n    if (!indexName) {\n      return {\n        partitionKey: this.tablePartitionKey,\n        sortKey: this.tableSortKey,\n      };\n    }\n    let schema = this.secondaryIndexSchemas.get(indexName);\n    if (!schema) {\n      throw new Error(`Cannot find schema for index: ${indexName}. Use 'addGlobalSecondaryIndex' or 'addLocalSecondaryIndex' to add index`);\n    }\n    return schema;\n  }\n\n  /**\n   * Validate the table construct.\n   *\n   * @returns an array of validation error message\n   */\n  protected validate(): string[] {\n    const errors = new Array<string>();\n\n    if (!this.tablePartitionKey) {\n      errors.push('a partition key must be specified');\n    }\n    if (this.localSecondaryIndexes.length > 0 && !this.tableSortKey) {\n      errors.push('a sort key of the table must be specified to add local secondary indexes');\n    }\n\n    if (this.globalReplicaCustomResources.length > 0 && this.billingMode === BillingMode.PROVISIONED) {\n      const writeAutoScaleAttribute = this.tableScaling.scalableWriteAttribute;\n      if (!writeAutoScaleAttribute) {\n        errors.push('A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity. ' +\n          'Use the autoScaleWriteCapacity() method to enable it.');\n      } else if (!writeAutoScaleAttribute._scalingPolicyCreated) {\n        errors.push('A global Table that uses PROVISIONED as the billing mode needs auto-scaled write capacity with a policy. ' +\n          'Call one of the scaleOn*() methods of the object returned from autoScaleWriteCapacity()');\n      }\n    }\n\n    return errors;\n  }\n\n  /**\n   * Validate read and write capacity are not specified for on-demand tables (billing mode PAY_PER_REQUEST).\n   *\n   * @param props read and write capacity properties\n   */\n  private validateProvisioning(props: { readCapacity?: number, writeCapacity?: number }): void {\n    if (this.billingMode === BillingMode.PAY_PER_REQUEST) {\n      if (props.readCapacity !== undefined || props.writeCapacity !== undefined) {\n        throw new Error('you cannot provision read and write capacity for a table with PAY_PER_REQUEST billing mode');\n      }\n    }\n  }\n\n  /**\n   * Validate index name to check if a duplicate name already exists.\n   *\n   * @param indexName a name of global or local secondary index\n   */\n  private validateIndexName(indexName: string) {\n    if (this.secondaryIndexSchemas.has(indexName)) {\n      // a duplicate index name causes validation exception, status code 400, while trying to create CFN stack\n      throw new Error(`a duplicate index name, ${indexName}, is not allowed`);\n    }\n  }\n\n  /**\n   * Validate non-key attributes by checking limits within secondary index, which may vary in future.\n   *\n   * @param nonKeyAttributes a list of non-key attribute names\n   */\n  private validateNonKeyAttributes(nonKeyAttributes: string[]) {\n    if (this.nonKeyAttributes.size + nonKeyAttributes.length > 100) {\n      // https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html#limits-secondary-indexes\n      throw new RangeError('a maximum number of nonKeyAttributes across all of secondary indexes is 100');\n    }\n\n    // store all non-key attributes\n    nonKeyAttributes.forEach(att => this.nonKeyAttributes.add(att));\n  }\n\n  private buildIndexKeySchema(partitionKey: Attribute, sortKey?: Attribute): CfnTable.KeySchemaProperty[] {\n    this.registerAttribute(partitionKey);\n    const indexKeySchema: CfnTable.KeySchemaProperty[] = [\n      { attributeName: partitionKey.name, keyType: HASH_KEY_TYPE },\n    ];\n\n    if (sortKey) {\n      this.registerAttribute(sortKey);\n      indexKeySchema.push({ attributeName: sortKey.name, keyType: RANGE_KEY_TYPE });\n    }\n\n    return indexKeySchema;\n  }\n\n  private buildIndexProjection(props: SecondaryIndexProps): CfnTable.ProjectionProperty {\n    if (props.projectionType === ProjectionType.INCLUDE && !props.nonKeyAttributes) {\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-dynamodb-projectionobject.html\n      throw new Error(`non-key attributes should be specified when using ${ProjectionType.INCLUDE} projection type`);\n    }\n\n    if (props.projectionType !== ProjectionType.INCLUDE && props.nonKeyAttributes) {\n      // this combination causes validation exception, status code 400, while trying to create CFN stack\n      throw new Error(`non-key attributes should not be specified when not using ${ProjectionType.INCLUDE} projection type`);\n    }\n\n    if (props.nonKeyAttributes) {\n      this.validateNonKeyAttributes(props.nonKeyAttributes);\n    }\n\n    return {\n      projectionType: props.projectionType ?? ProjectionType.ALL,\n      nonKeyAttributes: props.nonKeyAttributes ?? undefined,\n    };\n  }\n\n  private findKey(keyType: string) {\n    return this.keySchema.find(prop => prop.keyType === keyType);\n  }\n\n  private addKey(attribute: Attribute, keyType: string) {\n    const existingProp = this.findKey(keyType);\n    if (existingProp) {\n      throw new Error(`Unable to set ${attribute.name} as a ${keyType} key, because ${existingProp.attributeName} is a ${keyType} key`);\n    }\n    this.registerAttribute(attribute);\n    this.keySchema.push({\n      attributeName: attribute.name,\n      keyType,\n    });\n    return this;\n  }\n\n  /**\n   * Register the key attribute of table or secondary index to assemble attribute definitions of TableResourceProps.\n   *\n   * @param attribute the key attribute of table or secondary index\n   */\n  private registerAttribute(attribute: Attribute) {\n    const { name, type } = attribute;\n    const existingDef = this.attributeDefinitions.find(def => def.attributeName === name);\n    if (existingDef && existingDef.attributeType !== type) {\n      throw new Error(`Unable to specify ${name} as ${type} because it was already defined as ${existingDef.attributeType}`);\n    }\n    if (!existingDef) {\n      this.attributeDefinitions.push({\n        attributeName: name,\n        attributeType: type,\n      });\n    }\n  }\n\n  /**\n   * Return the role that will be used for AutoScaling\n   */\n  private makeScalingRole(): iam.IRole {\n    // Use a Service Linked Role.\n    // https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-service-linked-roles.html\n    return iam.Role.fromRoleArn(this, 'ScalingRole', Stack.of(this).formatArn({\n      service: 'iam',\n      region: '',\n      resource: 'role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com',\n      resourceName: 'AWSServiceRoleForApplicationAutoScaling_DynamoDBTable',\n    }));\n  }\n\n  /**\n   * Creates replica tables\n   *\n   * @param regions regions where to create tables\n   */\n  private createReplicaTables(regions: string[], timeout?: Duration, waitForReplicationToFinish?: boolean) {\n    const stack = Stack.of(this);\n\n    if (!Token.isUnresolved(stack.region) && regions.includes(stack.region)) {\n      throw new Error('`replicationRegions` cannot include the region where this stack is deployed.');\n    }\n\n    const provider = ReplicaProvider.getOrCreate(this, { timeout });\n\n    // Documentation at https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/V2gt_IAM.html\n    // is currently incorrect. AWS Support recommends `dynamodb:*` in both source and destination regions\n\n    const onEventHandlerPolicy = new SourceTableAttachedPolicy(this, provider.onEventHandler.role!);\n    const isCompleteHandlerPolicy = new SourceTableAttachedPolicy(this, provider.isCompleteHandler.role!);\n\n    // Permissions in the source region\n    this.grant(onEventHandlerPolicy, 'dynamodb:*');\n    this.grant(isCompleteHandlerPolicy, 'dynamodb:DescribeTable');\n\n    let previousRegion: CustomResource | undefined;\n    let previousRegionCondition: CfnCondition | undefined;\n    for (const region of new Set(regions)) { // Remove duplicates\n      // Use multiple custom resources because multiple create/delete\n      // updates cannot be combined in a single API call.\n      const currentRegion = new CustomResource(this, `Replica${region}`, {\n        serviceToken: provider.provider.serviceToken,\n        resourceType: 'Custom::DynamoDBReplica',\n        properties: {\n          TableName: this.tableName,\n          Region: region,\n          SkipReplicationCompletedWait: waitForReplicationToFinish == null\n            ? undefined\n            // CFN changes Custom Resource properties to strings anyways,\n            // so let's do that ourselves to make it clear in the handler this is a string, not a boolean\n            : (!waitForReplicationToFinish).toString(),\n        },\n      });\n      currentRegion.node.addDependency(\n        onEventHandlerPolicy.policy,\n        isCompleteHandlerPolicy.policy,\n      );\n      this.globalReplicaCustomResources.push(currentRegion);\n\n      // Deploy time check to prevent from creating a replica in the region\n      // where this stack is deployed. Only needed for environment agnostic\n      // stacks.\n      let createReplica: CfnCondition | undefined;\n      if (Token.isUnresolved(stack.region)) {\n        createReplica = new CfnCondition(this, `StackRegionNotEquals${region}`, {\n          expression: Fn.conditionNot(Fn.conditionEquals(region, Aws.REGION)),\n        });\n        const cfnCustomResource = currentRegion.node.defaultChild as CfnCustomResource;\n        cfnCustomResource.cfnOptions.condition = createReplica;\n      }\n\n      // Save regional arns for grantXxx() methods\n      this.regionalArns.push(stack.formatArn({\n        region,\n        service: 'dynamodb',\n        resource: 'table',\n        resourceName: this.tableName,\n      }));\n\n      // We need to create/delete regions sequentially because we cannot\n      // have multiple table updates at the same time. The `isCompleteHandler`\n      // of the provider waits until the replica is in an ACTIVE state.\n      if (previousRegion) {\n        if (previousRegionCondition) {\n          // we can't simply use a Dependency,\n          // because the previousRegion is protected by the \"different region\" Condition,\n          // and you can't have Fn::If in DependsOn.\n          // Instead, rely on Ref adding a dependency implicitly!\n          const previousRegionCfnResource = previousRegion.node.defaultChild as CfnResource;\n          const currentRegionCfnResource = currentRegion.node.defaultChild as CfnResource;\n          currentRegionCfnResource.addMetadata('DynamoDbReplicationDependency',\n            Fn.conditionIf(previousRegionCondition.logicalId, previousRegionCfnResource.ref, Aws.NO_VALUE));\n        } else {\n          currentRegion.node.addDependency(previousRegion);\n        }\n      }\n\n      previousRegion = currentRegion;\n      previousRegionCondition = createReplica;\n    }\n\n    // Permissions in the destination regions (outside of the loop to\n    // minimize statements in the policy)\n    onEventHandlerPolicy.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({\n      actions: ['dynamodb:*'],\n      resources: this.regionalArns,\n    }));\n  }\n\n  /**\n   * Whether this table has indexes\n   */\n  protected get hasIndex(): boolean {\n    return this.globalSecondaryIndexes.length + this.localSecondaryIndexes.length > 0;\n  }\n\n  /**\n   * Set up key properties and return the Table encryption property from the\n   * user's configuration.\n   */\n  private parseEncryption(props: TableProps): { sseSpecification: CfnTableProps['sseSpecification'], encryptionKey?: kms.IKey } {\n    let encryptionType = props.encryption;\n\n    if (encryptionType != null && props.serverSideEncryption != null) {\n      throw new Error('Only one of encryption and serverSideEncryption can be specified, but both were provided');\n    }\n\n    if (props.serverSideEncryption && props.encryptionKey) {\n      throw new Error('encryptionKey cannot be specified when serverSideEncryption is specified. Use encryption instead');\n    }\n\n    if (encryptionType === undefined) {\n      encryptionType = props.encryptionKey != null\n        // If there is a configured encryptionKey, the encryption is implicitly CUSTOMER_MANAGED\n        ? TableEncryption.CUSTOMER_MANAGED\n        // Otherwise, if severSideEncryption is enabled, it's AWS_MANAGED; else undefined (do not set anything)\n        : props.serverSideEncryption ? TableEncryption.AWS_MANAGED : undefined;\n    }\n\n    if (encryptionType !== TableEncryption.CUSTOMER_MANAGED && props.encryptionKey) {\n      throw new Error('`encryptionKey cannot be specified unless encryption is set to TableEncryption.CUSTOMER_MANAGED (it was set to ${encryptionType})`');\n    }\n\n    if (encryptionType === TableEncryption.CUSTOMER_MANAGED && props.replicationRegions) {\n      throw new Error('TableEncryption.CUSTOMER_MANAGED is not supported by DynamoDB Global Tables (where replicationRegions was set)');\n    }\n\n    switch (encryptionType) {\n      case TableEncryption.CUSTOMER_MANAGED:\n        const encryptionKey = props.encryptionKey ?? new kms.Key(this, 'Key', {\n          description: `Customer-managed key auto-created for encrypting DynamoDB table at ${this.node.path}`,\n          enableKeyRotation: true,\n        });\n\n        return {\n          sseSpecification: { sseEnabled: true, kmsMasterKeyId: encryptionKey.keyArn, sseType: 'KMS' },\n          encryptionKey,\n        };\n\n      case TableEncryption.AWS_MANAGED:\n        // Not specifying \"sseType: 'KMS'\" here because it would cause phony changes to existing stacks.\n        return { sseSpecification: { sseEnabled: true } };\n\n      case TableEncryption.DEFAULT:\n        return { sseSpecification: { sseEnabled: false } };\n\n      case undefined:\n        // Not specifying \"sseEnabled: false\" here because it would cause phony changes to existing stacks.\n        return { sseSpecification: undefined };\n\n      default:\n        throw new Error(`Unexpected 'encryptionType': ${encryptionType}`);\n    }\n  }\n}\n\n/**\n * Data types for attributes within a table\n *\n * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes\n */\nexport enum AttributeType {\n  /** Up to 400KiB of binary data (which must be encoded as base64 before sending to DynamoDB) */\n  BINARY = 'B',\n  /** Numeric values made of up to 38 digits (positive, negative or zero) */\n  NUMBER = 'N',\n  /** Up to 400KiB of UTF-8 encoded text */\n  STRING = 'S',\n}\n\n/**\n * DynamoDB's Read/Write capacity modes.\n */\nexport enum BillingMode {\n  /**\n   * Pay only for what you use. You don't configure Read/Write capacity units.\n   */\n  PAY_PER_REQUEST = 'PAY_PER_REQUEST',\n  /**\n   * Explicitly specified Read/Write capacity units.\n   */\n  PROVISIONED = 'PROVISIONED',\n}\n\n/**\n * The set of attributes that are projected into the index\n *\n * @see https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Projection.html\n */\nexport enum ProjectionType {\n  /** Only the index and primary keys are projected into the index. */\n  KEYS_ONLY = 'KEYS_ONLY',\n  /** Only the specified table attributes are projected into the index. The list of projected attributes is in `nonKeyAttributes`. */\n  INCLUDE = 'INCLUDE',\n  /** All of the table attributes are projected into the index. */\n  ALL = 'ALL'\n}\n\n/**\n * When an item in the table is modified, StreamViewType determines what information\n * is written to the stream for this table.\n *\n * @see https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_StreamSpecification.html\n */\nexport enum StreamViewType {\n  /** The entire item, as it appears after it was modified, is written to the stream. */\n  NEW_IMAGE = 'NEW_IMAGE',\n  /** The entire item, as it appeared before it was modified, is written to the stream. */\n  OLD_IMAGE = 'OLD_IMAGE',\n  /** Both the new and the old item images of the item are written to the stream. */\n  NEW_AND_OLD_IMAGES = 'NEW_AND_OLD_IMAGES',\n  /** Only the key attributes of the modified item are written to the stream. */\n  KEYS_ONLY = 'KEYS_ONLY'\n}\n\n/**\n * DynamoDB's table class.\n *\n * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html\n */\nexport enum TableClass {\n  /** Default table class for DynamoDB. */\n  STANDARD = 'STANDARD',\n\n  /** Table class for DynamoDB that reduces storage costs compared to existing DynamoDB Standard tables. */\n  STANDARD_INFREQUENT_ACCESS = 'STANDARD_INFREQUENT_ACCESS',\n}\n\n/**\n * Just a convenient way to keep track of both attributes\n */\ninterface ScalableAttributePair {\n  scalableReadAttribute?: ScalableTableAttribute;\n  scalableWriteAttribute?: ScalableTableAttribute;\n}\n\n/**\n * An inline policy that is logically bound to the source table of a DynamoDB Global Tables\n * \"cluster\". This is here to ensure permissions are removed as part of (and not before) the\n * CleanUp phase of a stack update, when a replica is removed (or the entire \"cluster\" gets\n * replaced).\n *\n * If statements are added directly to the handler roles (as opposed to in a separate inline\n * policy resource), new permissions are in effect before clean up happens, and so replicas that\n * need to be dropped can no longer be due to lack of permissions.\n */\nclass SourceTableAttachedPolicy extends CoreConstruct implements iam.IGrantable {\n  public readonly grantPrincipal: iam.IPrincipal;\n  public readonly policy: iam.IManagedPolicy;\n\n  public constructor(sourceTable: Table, role: iam.IRole) {\n    super(sourceTable, `SourceTableAttachedManagedPolicy-${Names.nodeUniqueId(role.node)}`);\n\n    const policy = new iam.ManagedPolicy(this, 'Resource', {\n      // A CF update of the description property of a managed policy requires\n      // a replacement. Use the table name in the description to force a managed\n      // policy replacement when the table name changes. This way we preserve permissions\n      // to delete old replicas in case of a table replacement.\n      description: `DynamoDB replication managed policy for table ${sourceTable.tableName}`,\n      roles: [role],\n    });\n    this.policy = policy;\n    this.grantPrincipal = new SourceTableAttachedPrincipal(role, policy);\n  }\n}\n\n/**\n * An `IPrincipal` entity that can be used as the target of `grant` calls, used by the\n * `SourceTableAttachedPolicy` class so it can act as an `IGrantable`.\n */\nclass SourceTableAttachedPrincipal extends iam.PrincipalBase {\n  public constructor(private readonly role: iam.IRole, private readonly policy: iam.ManagedPolicy) {\n    super();\n  }\n\n  public get policyFragment(): iam.PrincipalPolicyFragment {\n    return this.role.policyFragment;\n  }\n\n  public addToPrincipalPolicy(statement: iam.PolicyStatement): iam.AddToPrincipalPolicyResult {\n    this.policy.addStatements(statement);\n    return {\n      policyDependable: this.policy,\n      statementAdded: true,\n    };\n  }\n\n  public dedupeString(): string | undefined {\n    return undefined;\n  }\n}\n"]}