Database Services

/**
 * DynamoDB table for NoSQL data storage
 */
class Table extends Resource implements ITable {
  constructor(scope: Construct, id: string, props: TableProps);
  
  /**
   * Import an existing table by name
   */
  static fromTableName(scope: Construct, id: string, tableName: string): ITable;
  
  /**
   * Import an existing table by ARN
   */
  static fromTableArn(scope: Construct, id: string, tableArn: string): ITable;
  
  /**
   * Import an existing table by attributes
   */
  static fromTableAttributes(scope: Construct, id: string, attrs: TableAttributes): ITable;
  
  /**
   * Add a global secondary index to the table
   */
  addGlobalSecondaryIndex(props: GlobalSecondaryIndexProps): void;
  
  /**
   * Add a local secondary index to the table
   */
  addLocalSecondaryIndex(props: LocalSecondaryIndexProps): void;
  
  /**
   * Grant read permissions for this table and its indexes to an IAM principal
   */
  grantReadData(grantee: IGrantable): Grant;
  
  /**
   * Grant write permissions for this table and its indexes to an IAM principal
   */
  grantWriteData(grantee: IGrantable): Grant;
  
  /**
   * Grant read and write permissions for this table and its indexes to an IAM principal
   */
  grantReadWriteData(grantee: IGrantable): Grant;
  
  /**
   * Grant full permissions for this table and its indexes to an IAM principal
   */
  grantFullAccess(grantee: IGrantable): Grant;
  
  /**
   * Grant permissions for streams on this table to an IAM principal
   */
  grantStreamRead(grantee: IGrantable): Grant;
  
  readonly tableArn: string;
  readonly tableName: string;
  readonly tableStreamArn?: string;
  readonly encryptionKey?: IKey;
}

/**
 * RDS database instance
 */
class DatabaseInstance extends DatabaseInstanceBase implements IDatabaseInstance {
  constructor(scope: Construct, id: string, props: DatabaseInstanceProps);
  
  /**
   * Import an existing database instance by endpoint
   */
  static fromDatabaseInstanceAttributes(scope: Construct, id: string, attrs: DatabaseInstanceAttributes): IDatabaseInstance;
  
  /**
   * Add a rotation schedule for the master password
   */
  addRotationSingleUser(options?: RotationSingleUserOptions): DatabaseRotation;
  
  /**
   * Add a rotation schedule for additional users
   */
  addRotationMultiUser(id: string, options: RotationMultiUserOptions): DatabaseRotation;
  
  readonly instanceIdentifier: string;
  readonly instanceEndpoint: Endpoint;
  readonly instanceResourceId?: string;
  readonly engine?: IInstanceEngine;
  readonly connections: Connections;
}

/**
 * RDS database cluster for Aurora
 */
class DatabaseCluster extends DatabaseClusterBase implements IDatabaseCluster {
  constructor(scope: Construct, id: string, props: DatabaseClusterProps);
  
  /**
   * Import an existing cluster by identifier
   */
  static fromDatabaseClusterAttributes(scope: Construct, id: string, attrs: DatabaseClusterAttributes): IDatabaseCluster;
  
  /**
   * Add a reader endpoint to the cluster
   */
  addRotationSingleUser(options?: RotationSingleUserOptions): DatabaseRotation;
  
  /**
   * Add a rotation schedule for additional users
   */
  addRotationMultiUser(id: string, options: RotationMultiUserOptions): DatabaseRotation;
  
  readonly clusterIdentifier: string;
  readonly clusterEndpoint: Endpoint;
  readonly clusterReadEndpoint: Endpoint;
  readonly clusterResourceIdentifier: string;
  readonly connections: Connections;
  readonly engine?: IClusterEngine;
}

interface TableProps {
  readonly partitionKey: Attribute;
  readonly billingMode?: BillingMode;
  readonly contributorInsightsEnabled?: boolean;
  readonly deletionProtection?: boolean;
  readonly encryption?: TableEncryption;
  readonly encryptionKey?: IKey;
  readonly globalSecondaryIndexes?: GlobalSecondaryIndexProps[];
  readonly kinesisStream?: IStream;
  readonly localSecondaryIndexes?: LocalSecondaryIndexProps[];
  readonly pointInTimeRecovery?: boolean;
  readonly readCapacity?: number;
  readonly removalPolicy?: RemovalPolicy;
  readonly replicationRegions?: string[];
  readonly replicationTimeout?: Duration;
  readonly sortKey?: Attribute;
  readonly stream?: StreamViewType;
  readonly tableName?: string;
  readonly timeToLiveAttribute?: string;
  readonly waitForReplicationToFinish?: boolean;
  readonly writeCapacity?: number;
}

interface DatabaseInstanceProps {
  readonly engine: IInstanceEngine;
  readonly allocatedStorage?: number;
  readonly allowMajorVersionUpgrade?: boolean;
  readonly autoMinorVersionUpgrade?: boolean;
  readonly availabilityZone?: string;
  readonly backupRetention?: Duration;
  readonly cloudwatchLogsExports?: string[];
  readonly cloudwatchLogsRetention?: RetentionDays;
  readonly cloudwatchLogsRetentionRole?: IRole;
  readonly copyTagsToSnapshot?: boolean;
  readonly credentials?: Credentials;
  readonly databaseName?: string;
  readonly deleteAutomatedBackups?: boolean;
  readonly deletionProtection?: boolean;
  readonly domain?: string;
  readonly domainRole?: IRole;
  readonly enablePerformanceInsights?: boolean;
  readonly instanceIdentifier?: string;
  readonly instanceType?: InstanceType;
  readonly iops?: number;
  readonly licenseModel?: LicenseModel;
  readonly maxAllocatedStorage?: number;
  readonly monitoringInterval?: Duration;
  readonly monitoringRole?: IRole;
  readonly multiAz?: boolean;
  readonly networkType?: NetworkType;
  readonly optionGroup?: IOptionGroup;
  readonly parameterGroup?: IParameterGroup;
  readonly performanceInsightEncryptionKey?: IKey;
  readonly performanceInsightRetention?: PerformanceInsightRetention;
  readonly port?: number;
  readonly preferredBackupWindow?: string;
  readonly preferredMaintenanceWindow?: string;
  readonly processorFeatures?: ProcessorFeatures;
  readonly publiclyAccessible?: boolean;
  readonly removalPolicy?: RemovalPolicy;
  readonly s3ExportBuckets?: IBucket[];
  readonly s3ExportRole?: IRole;
  readonly s3ImportBuckets?: IBucket[];
  readonly s3ImportRole?: IRole;
  readonly securityGroups?: ISecurityGroup[];
  readonly storageEncrypted?: boolean;
  readonly storageEncryptionKey?: IKey;
  readonly storageType?: StorageType;
  readonly subnetGroup?: ISubnetGroup;
  readonly timezone?: string;
  readonly vpc?: IVpc;
  readonly vpcSubnets?: SubnetSelection;
}

enum AttributeType {
  BINARY = "B",
  NUMBER = "N",
  STRING = "S"
}

enum BillingMode {
  PAY_PER_REQUEST = "PAY_PER_REQUEST",
  PROVISIONED = "PROVISIONED"
}

enum ProjectionType {
  KEYS_ONLY = "KEYS_ONLY",
  INCLUDE = "INCLUDE",
  ALL = "ALL"
}

enum StreamViewType {
  KEYS_ONLY = "KEYS_ONLY",
  NEW_IMAGE = "NEW_IMAGE",
  OLD_IMAGE = "OLD_IMAGE",
  NEW_AND_OLD_IMAGES = "NEW_AND_OLD_IMAGES"
}

enum StorageType {
  STANDARD = "standard",
  GP2 = "gp2",
  GP3 = "gp3",
  IO1 = "io1",
  IO2 = "io2"
}

enum LicenseModel {
  LICENSE_INCLUDED = "license-included",
  BRING_YOUR_OWN_LICENSE = "bring-your-own-license",
  GENERAL_PUBLIC_LICENSE = "general-public-license"
}