terraconstructs 0.0.22 → 0.0.24

package/lib/aws/storage/shared.d.ts

@@ -0,0 +1,419 @@
+import { IAwsConstruct } from "../aws-construct";
+import * as cloudwatch from "../cloudwatch";
+import * as kms from "../encryption";
+import * as iam from "../iam";
+/**
+ * Supported DynamoDB table operations.
+ */
+export declare enum Operation {
+    /** GetItem */
+    GET_ITEM = "GetItem",
+    /** BatchGetItem */
+    BATCH_GET_ITEM = "BatchGetItem",
+    /** Scan */
+    SCAN = "Scan",
+    /** Query */
+    QUERY = "Query",
+    /** GetRecords */
+    GET_RECORDS = "GetRecords",
+    /** PutItem */
+    PUT_ITEM = "PutItem",
+    /** DeleteItem */
+    DELETE_ITEM = "DeleteItem",
+    /** UpdateItem */
+    UPDATE_ITEM = "UpdateItem",
+    /** BatchWriteItem */
+    BATCH_WRITE_ITEM = "BatchWriteItem",
+    /** TransactWriteItems */
+    TRANSACT_WRITE_ITEMS = "TransactWriteItems",
+    /** TransactGetItems */
+    TRANSACT_GET_ITEMS = "TransactGetItems",
+    /** ExecuteTransaction */
+    EXECUTE_TRANSACTION = "ExecuteTransaction",
+    /** BatchExecuteStatement */
+    BATCH_EXECUTE_STATEMENT = "BatchExecuteStatement",
+    /** ExecuteStatement */
+    EXECUTE_STATEMENT = "ExecuteStatement"
+}
+/**
+ * Options for configuring a system errors metric that considers multiple operations.
+ */
+export interface SystemErrorsForOperationsMetricOptions extends cloudwatch.MetricOptions {
+    /**
+     * The operations to apply the metric to.
+     *
+     * @default - All operations available by DynamoDB tables will be considered.
+     */
+    readonly operations?: Operation[];
+}
+/**
+ * Options for configuring metrics that considers multiple operations.
+ */
+export interface OperationsMetricOptions extends SystemErrorsForOperationsMetricOptions {
+}
+/**
+ * Represents an attribute for describing the key schema for the table
+ * and indexes.
+ */
+export interface Attribute {
+    /**
+     * The name of an attribute.
+     */
+    readonly name: string;
+    /**
+     * The data type of an attribute.
+     */
+    readonly type: AttributeType;
+}
+/**
+ * Reference to WarmThroughput for a DynamoDB table
+ */
+export interface WarmThroughput {
+    /**
+     * Configures the number of read units per second a table will be able to handle instantly
+     * @default - no readUnitsPerSecond configured
+     */
+    readonly readUnitsPerSecond?: number;
+    /**
+     * Configures the number of write units per second a table will be able to handle instantly
+     * @default - no writeUnitsPerSecond configured
+     */
+    readonly writeUnitsPerSecond?: number;
+}
+/**
+ * Reference to PointInTimeRecovey Specification
+ * for continuous backups
+ */
+export interface PointInTimeRecoverySpecification {
+    /**
+     * Indicates whether point in time recovery is enabled (true) or disabled (false) on the table.
+     * @default false
+     */
+    readonly pointInTimeRecoveryEnabled: boolean;
+    /**
+     * The number of preceding days for which continuous backups are taken and maintained.
+     * Your table data is only recoverable to any point-in-time from within the configured recovery period.
+     * If no value is provided, the value will default to 35.
+     *
+     * NOTE: Unused pending upgrade to v5.98.0 of the AWS Provider for Terraform.
+     *
+     * @default 35
+     */
+    readonly recoveryPeriodInDays?: number;
+}
+/**
+ * Data types for attributes within a table
+ *
+ * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes
+ */
+export declare enum AttributeType {
+    /**
+     * Up to 400KiB of binary data (which must be encoded as base64 before sending to DynamoDB)
+     */
+    BINARY = "B",
+    /**
+     * Numeric values made of up to 38 digits (positive, negative or zero)
+     */
+    NUMBER = "N",
+    /**
+     * Up to 400KiB of UTF-8 encoded text
+     */
+    STRING = "S"
+}
+/**
+ * DynamoDB's Read/Write capacity modes.
+ */
+export declare enum BillingMode {
+    /**
+     * Pay only for what you use. You don't configure Read/Write capacity units.
+     */
+    PAY_PER_REQUEST = "PAY_PER_REQUEST",
+    /**
+     * Explicitly specified Read/Write capacity units.
+     */
+    PROVISIONED = "PROVISIONED"
+}
+/**
+ * The set of attributes that are projected into the index
+ *
+ * @see https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Projection.html
+ */
+export declare enum ProjectionType {
+    /**
+     * Only the index and primary keys are projected into the index.
+     */
+    KEYS_ONLY = "KEYS_ONLY",
+    /**
+     * Only the specified table attributes are projected into the index. The list
+     * of projected attributes is in `nonKeyAttributes`.
+     */
+    INCLUDE = "INCLUDE",
+    /**
+     * All of the table attributes are projected into the index.
+     */
+    ALL = "ALL"
+}
+/**
+ * DynamoDB's table class.
+ *
+ * @see https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html
+ */
+export declare enum TableClass {
+    /**
+     * Default table class for DynamoDB.
+     */
+    STANDARD = "STANDARD",
+    /**
+     * Table class for DynamoDB that reduces storage costs compared to existing DynamoDB
+     * standard tables.
+     */
+    STANDARD_INFREQUENT_ACCESS = "STANDARD_INFREQUENT_ACCESS"
+}
+/**
+ * What kind of server-side encryption to apply to this table.
+ */
+export declare enum TableEncryption {
+    /**
+     * Server-side KMS encryption with a master key owned by AWS.
+     */
+    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`.
+     */
+    CUSTOMER_MANAGED = "CUSTOMER_MANAGED",
+    /**
+     * Server-side KMS encryption with a master key managed by AWS.
+     */
+    AWS_MANAGED = "AWS_MANAGED"
+}
+/**
+ * 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
+ */
+export declare enum StreamViewType {
+    /**
+     * The entire item, as it appears after it was modified, is written to the stream.
+     */
+    NEW_IMAGE = "NEW_IMAGE",
+    /**
+     * The entire item, as it appeared before it was modified, is written to the stream.
+     */
+    OLD_IMAGE = "OLD_IMAGE",
+    /**
+     * Both the new and the old item images of the item are written to the stream.
+     */
+    NEW_AND_OLD_IMAGES = "NEW_AND_OLD_IMAGES",
+    /**
+     * Only the key attributes of the modified item are written to the stream.
+     */
+    KEYS_ONLY = "KEYS_ONLY"
+}
+/**
+ * Properties for a secondary index
+ */
+export interface SecondaryIndexProps {
+    /**
+     * The name of the secondary index.
+     */
+    readonly indexName: string;
+    /**
+     * The set of attributes that are projected into the secondary index.
+     * @default ALL
+     */
+    readonly projectionType?: ProjectionType;
+    /**
+     * The non-key attributes that are projected into the secondary index.
+     * @default - No additional attributes
+     */
+    readonly nonKeyAttributes?: string[];
+}
+/**
+ * Properties for a local secondary index
+ */
+export interface LocalSecondaryIndexProps extends SecondaryIndexProps {
+    /**
+     * The attribute of a sort key for the local secondary index.
+     */
+    readonly sortKey: Attribute;
+}
+/**
+ * An interface that represents a DynamoDB Table - either created with the CDK, or an existing one.
+ */
+export interface ITable extends IAwsConstruct {
+    /**
+     * Arn of the dynamodb table.
+     *
+     * @attribute
+     */
+    readonly tableArn: string;
+    /**
+     * Table name of the dynamodb table.
+     *
+     * @attribute
+     */
+    readonly tableName: string;
+    /**
+     * ARN of the table's stream, if there is one.
+     *
+     * @attribute
+     */
+    readonly tableStreamArn?: string;
+    /**
+     *
+     * Optional KMS encryption key associated with this table.
+     */
+    readonly encryptionKey?: kms.IKey;
+    /**
+     * 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: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * 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: iam.IGrantable, ...actions: string[]): iam.Grant;
+    /**
+     * Permits an IAM principal all data read operations from this table:
+     * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan.
+     *
+     * 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: iam.IGrantable): iam.Grant;
+    /**
+     * Permits an IAM Principal to list streams attached to current dynamodb table.
+     *
+     * @param grantee The principal (no-op if undefined)
+     */
+    grantTableListStreams(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * 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: iam.IGrantable): iam.Grant;
+    /**
+     * Permits an IAM principal all data write operations to this table:
+     * BatchWriteItem, PutItem, UpdateItem, DeleteItem.
+     *
+     * 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: iam.IGrantable): iam.Grant;
+    /**
+     * Permits an IAM principal to all data read/write operations to this table.
+     * BatchGetItem, GetRecords, GetShardIterator, Query, GetItem, Scan,
+     * BatchWriteItem, PutItem, UpdateItem, DeleteItem
+     *
+     * 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: iam.IGrantable): iam.Grant;
+    /**
+     * 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: iam.IGrantable): iam.Grant;
+    /**
+     * Metric for the number of Errors executing all Lambdas
+     */
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the consumed read capacity units
+     *
+     * @param props properties of a metric
+     */
+    metricConsumedReadCapacityUnits(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the consumed write capacity units
+     *
+     * @param props properties of a metric
+     */
+    metricConsumedWriteCapacityUnits(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the system errors
+     *
+     * @param props properties of a metric
+     *
+     * @deprecated use `metricSystemErrorsForOperations`
+     */
+    metricSystemErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the system errors this table
+     *
+     * @param props properties of a metric
+     *
+     */
+    metricSystemErrorsForOperations(props?: SystemErrorsForOperationsMetricOptions): cloudwatch.IMetric;
+    /**
+     * Metric for the user errors
+     *
+     * @param props properties of a metric
+     */
+    metricUserErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for the conditional check failed requests
+     *
+     * @param props properties of a metric
+     */
+    metricConditionalCheckFailedRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for throttled requests
+     *
+     * @param props properties of a metric
+     *
+     * @deprecated use `metricThrottledRequestsForOperations`
+     */
+    metricThrottledRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+    /**
+     * Metric for throttled requests
+     *
+     * @param props properties of a metric
+     *
+     */
+    metricThrottledRequestsForOperations(props?: OperationsMetricOptions): cloudwatch.IMetric;
+    /**
+     * Metric for the successful request latency
+     *
+     * @param props properties of a metric
+     *
+     */
+    metricSuccessfulRequestLatency(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
+}

package/lib/aws/storage/shared.js

@@ -0,0 +1,161 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-dynamodb/lib/shared.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamViewType = exports.TableEncryption = exports.TableClass = exports.ProjectionType = exports.BillingMode = exports.AttributeType = exports.Operation = void 0;
+/**
+ * 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 = Operation = {}));
+/**
+ * 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 = 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 = 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 = ProjectionType = {}));
+/**
+ * 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 = TableClass = {}));
+/**
+ * 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 = TableEncryption = {}));
+/**
+ * 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 = StreamViewType = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../src/aws/storage/shared.ts"],"names":[],"mappings":";AAAA,+FAA+F;;;AAO/F;;GAEG;AACH,IAAY,SA0CX;AA1CD,WAAY,SAAS;IACnB,cAAc;IACd,iCAAoB,CAAA;IAEpB,mBAAmB;IACnB,4CAA+B,CAAA;IAE/B,WAAW;IACX,0BAAa,CAAA;IAEb,YAAY;IACZ,4BAAe,CAAA;IAEf,iBAAiB;IACjB,uCAA0B,CAAA;IAE1B,cAAc;IACd,iCAAoB,CAAA;IAEpB,iBAAiB;IACjB,uCAA0B,CAAA;IAE1B,iBAAiB;IACjB,uCAA0B,CAAA;IAE1B,qBAAqB;IACrB,gDAAmC,CAAA;IAEnC,yBAAyB;IACzB,wDAA2C,CAAA;IAE3C,uBAAuB;IACvB,oDAAuC,CAAA;IAEvC,yBAAyB;IACzB,uDAA0C,CAAA;IAE1C,4BAA4B;IAC5B,8DAAiD,CAAA;IAEjD,uBAAuB;IACvB,mDAAsC,CAAA;AACxC,CAAC,EA1CW,SAAS,yBAAT,SAAS,QA0CpB;AA2ED;;;;GAIG;AACH,IAAY,aAeX;AAfD,WAAY,aAAa;IACvB;;OAEG;IACH,6BAAY,CAAA;IAEZ;;OAEG;IACH,6BAAY,CAAA;IAEZ;;OAEG;IACH,6BAAY,CAAA;AACd,CAAC,EAfW,aAAa,6BAAb,aAAa,QAexB;AAED;;GAEG;AACH,IAAY,WAUX;AAVD,WAAY,WAAW;IACrB;;OAEG;IACH,kDAAmC,CAAA;IAEnC;;OAEG;IACH,0CAA2B,CAAA;AAC7B,CAAC,EAVW,WAAW,2BAAX,WAAW,QAUtB;AAED;;;;GAIG;AACH,IAAY,cAgBX;AAhBD,WAAY,cAAc;IACxB;;OAEG;IACH,yCAAuB,CAAA;IAEvB;;;OAGG;IACH,qCAAmB,CAAA;IAEnB;;OAEG;IACH,6BAAW,CAAA;AACb,CAAC,EAhBW,cAAc,8BAAd,cAAc,QAgBzB;AAED;;;;GAIG;AACH,IAAY,UAWX;AAXD,WAAY,UAAU;IACpB;;OAEG;IACH,mCAAqB,CAAA;IAErB;;;OAGG;IACH,uEAAyD,CAAA;AAC3D,CAAC,EAXW,UAAU,0BAAV,UAAU,QAWrB;AAED;;GAEG;AACH,IAAY,eAsBX;AAtBD,WAAY,eAAe;IACzB;;OAEG;IACH,wCAAqB,CAAA;IAErB;;;;;;;;;OASG;IACH,wDAAqC,CAAA;IAErC;;OAEG;IACH,8CAA2B,CAAA;AAC7B,CAAC,EAtBW,eAAe,+BAAf,eAAe,QAsB1B;AAED;;;;;GAKG;AACH,IAAY,cAoBX;AApBD,WAAY,cAAc;IACxB;;OAEG;IACH,yCAAuB,CAAA;IAEvB;;OAEG;IACH,yCAAuB,CAAA;IAEvB;;OAEG;IACH,2DAAyC,CAAA;IAEzC;;OAEG;IACH,yCAAuB,CAAA;AACzB,CAAC,EApBW,cAAc,8BAAd,cAAc,QAoBzB","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.186.0/packages/aws-cdk-lib/aws-dynamodb/lib/shared.ts\n\nimport { IAwsConstruct } from \"../aws-construct\";\nimport * as cloudwatch from \"../cloudwatch\";\nimport * as kms from \"../encryption\";\nimport * as iam from \"../iam\";\n\n/**\n * Supported DynamoDB table operations.\n */\nexport enum Operation {\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 * Options for configuring a system errors metric that considers multiple operations.\n */\nexport interface SystemErrorsForOperationsMetricOptions\n  extends cloudwatch.MetricOptions {\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 * Options for configuring metrics that considers multiple operations.\n */\nexport interface OperationsMetricOptions\n  extends SystemErrorsForOperationsMetricOptions {}\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 * Reference to WarmThroughput for a DynamoDB table\n */\nexport interface WarmThroughput {\n  /**\n   * Configures the number of read units per second a table will be able to handle instantly\n   * @default - no readUnitsPerSecond configured\n   */\n  readonly readUnitsPerSecond?: number;\n  /**\n   * Configures the number of write units per second a table will be able to handle instantly\n   * @default - no writeUnitsPerSecond configured\n   */\n  readonly writeUnitsPerSecond?: number;\n}\n\n/**\n * Reference to PointInTimeRecovey Specification\n * for continuous backups\n */\nexport interface PointInTimeRecoverySpecification {\n  /**\n   * Indicates whether point in time recovery is enabled (true) or disabled (false) on the table.\n   * @default false\n   */\n  readonly pointInTimeRecoveryEnabled: boolean;\n  /**\n   * The number of preceding days for which continuous backups are taken and maintained.\n   * Your table data is only recoverable to any point-in-time from within the configured recovery period.\n   * If no value is provided, the value will default to 35.\n   *\n   * NOTE: Unused pending upgrade to v5.98.0 of the AWS Provider for Terraform.\n   *\n   * @default 35\n   */\n  readonly recoveryPeriodInDays?: number;\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  /**\n   * Up to 400KiB of binary data (which must be encoded as base64 before sending to DynamoDB)\n   */\n  BINARY = \"B\",\n\n  /**\n   * Numeric values made of up to 38 digits (positive, negative or zero)\n   */\n  NUMBER = \"N\",\n\n  /**\n   * Up to 400KiB of UTF-8 encoded text\n   */\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  /**\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  /**\n   * Only the index and primary keys are projected into the index.\n   */\n  KEYS_ONLY = \"KEYS_ONLY\",\n\n  /**\n   * Only the specified table attributes are projected into the index. The list\n   * of projected attributes is in `nonKeyAttributes`.\n   */\n  INCLUDE = \"INCLUDE\",\n\n  /**\n   * All of the table attributes are projected into the index.\n   */\n  ALL = \"ALL\",\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  /**\n   * Default table class for DynamoDB.\n   */\n  STANDARD = \"STANDARD\",\n\n  /**\n   * Table class for DynamoDB that reduces storage costs compared to existing DynamoDB\n   * standard tables.\n   */\n  STANDARD_INFREQUENT_ACCESS = \"STANDARD_INFREQUENT_ACCESS\",\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 * 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  /**\n   * The entire item, as it appears after it was modified, is written to the stream.\n   */\n  NEW_IMAGE = \"NEW_IMAGE\",\n\n  /**\n   * The entire item, as it appeared before it was modified, is written to the stream.\n   */\n  OLD_IMAGE = \"OLD_IMAGE\",\n\n  /**\n   * Both the new and the old item images of the item are written to the stream.\n   */\n  NEW_AND_OLD_IMAGES = \"NEW_AND_OLD_IMAGES\",\n\n  /**\n   * Only the key attributes of the modified item are written to the stream.\n   */\n  KEYS_ONLY = \"KEYS_ONLY\",\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 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 IAwsConstruct {\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(\n    metricName: string,\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * Metric for the consumed read capacity units\n   *\n   * @param props properties of a metric\n   */\n  metricConsumedReadCapacityUnits(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * Metric for the consumed write capacity units\n   *\n   * @param props properties of a metric\n   */\n  metricConsumedWriteCapacityUnits(\n    props?: cloudwatch.MetricOptions,\n  ): 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(\n    props?: SystemErrorsForOperationsMetricOptions,\n  ): 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(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n\n  /**\n   * Metric for throttled requests\n   *\n   * @param props properties of a metric\n   *\n   * @deprecated use `metricThrottledRequestsForOperations`\n   */\n  metricThrottledRequests(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for throttled requests\n   *\n   * @param props properties of a metric\n   *\n   */\n  metricThrottledRequestsForOperations(\n    props?: OperationsMetricOptions,\n  ): cloudwatch.IMetric;\n\n  /**\n   * Metric for the successful request latency\n   *\n   * @param props properties of a metric\n   *\n   */\n  metricSuccessfulRequestLatency(\n    props?: cloudwatch.MetricOptions,\n  ): cloudwatch.Metric;\n}\n"]}