@epilot360/icons 0.0.2 → 0.1.0

package/iac/node_modules/aws-cdk-lib/aws-docdb/README.md

@@ -1,153 +0,0 @@
-# Amazon DocumentDB Construct Library
-
-
-## Starting a Clustered Database
-
-To set up a clustered DocumentDB database, define a `DatabaseCluster`. You must
-always launch a database in a VPC. Use the `vpcSubnets` attribute to control whether
-your instances will be launched privately or publicly:
-
-```ts
-declare const vpc: ec2.Vpc;
-const cluster = new docdb.DatabaseCluster(this, 'Database', {
-  masterUser: {
-    username: 'myuser', // NOTE: 'admin' is reserved by DocumentDB
-    excludeCharacters: '\"@/:', // optional, defaults to the set "\"@/" and is also used for eventually created rotations
-    secretName: '/myapp/mydocdb/masteruser', // optional, if you prefer to specify the secret name
-  },
-  instanceType: ec2.InstanceType.of(ec2.InstanceClass.MEMORY5, ec2.InstanceSize.LARGE),
-  vpcSubnets: {
-    subnetType: ec2.SubnetType.PUBLIC,
-  },
-  vpc,
-});
-```
-
-By default, the master password will be generated and stored in AWS Secrets Manager with auto-generated description.
-
-Your cluster will be empty by default.
-
-## Connecting
-
-To control who can access the cluster, use the `.connections` attribute. DocumentDB databases have a default port, so
-you don't need to specify the port:
-
-```ts
-declare const cluster: docdb.DatabaseCluster;
-cluster.connections.allowDefaultPortFromAnyIpv4('Open to the world');
-```
-
-The endpoints to access your database cluster will be available as the `.clusterEndpoint` and `.clusterReadEndpoint`
-attributes:
-
-```ts
-declare const cluster: docdb.DatabaseCluster;
-const writeAddress = cluster.clusterEndpoint.socketAddress;   // "HOSTNAME:PORT"
-```
-
-If you have existing security groups you would like to add to the cluster, use the `addSecurityGroups` method. Security
-groups added in this way will not be managed by the `Connections` object of the cluster.
-
-```ts
-declare const vpc: ec2.Vpc;
-declare const cluster: docdb.DatabaseCluster;
-
-const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', {
-  vpc,
-});
-cluster.addSecurityGroups(securityGroup);
-```
-
-## Deletion protection
-
-Deletion protection can be enabled on an Amazon DocumentDB cluster to prevent accidental deletion of the cluster:
-
-```ts
-declare const vpc: ec2.Vpc;
-const cluster = new docdb.DatabaseCluster(this, 'Database', {
-  masterUser: {
-    username: 'myuser',
-  },
-  instanceType: ec2.InstanceType.of(ec2.InstanceClass.MEMORY5, ec2.InstanceSize.LARGE),
-  vpcSubnets: {
-    subnetType: ec2.SubnetType.PUBLIC,
-  },
-  vpc,
-  deletionProtection: true, // Enable deletion protection.
-});
-```
-
-## Rotating credentials
-
-When the master password is generated and stored in AWS Secrets Manager, it can be rotated automatically:
-
-```ts
-declare const cluster: docdb.DatabaseCluster;
-cluster.addRotationSingleUser(); // Will rotate automatically after 30 days
-```
-
-[example of setting up master password rotation for a cluster](test/integ.cluster-rotation.lit.ts)
-
-The multi user rotation scheme is also available:
-
-```ts
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
-
-declare const myImportedSecret: secretsmanager.Secret;
-declare const cluster: docdb.DatabaseCluster;
-
-cluster.addRotationMultiUser('MyUser', {
-  secret: myImportedSecret, // This secret must have the `masterarn` key
-});
-```
-
-It's also possible to create user credentials together with the cluster and add rotation:
-
-```ts
-declare const cluster: docdb.DatabaseCluster;
-const myUserSecret = new docdb.DatabaseSecret(this, 'MyUserSecret', {
-  username: 'myuser',
-  masterSecret: cluster.secret,
-});
-const myUserSecretAttached = myUserSecret.attach(cluster); // Adds DB connections information in the secret
-
-cluster.addRotationMultiUser('MyUser', { // Add rotation using the multi user scheme
-  secret: myUserSecretAttached, // This secret must have the `masterarn` key
-});
-```
-
-**Note**: This user must be created manually in the database using the master credentials.
-The rotation will start as soon as this user exists.
-
-See also [@aws-cdk/aws-secretsmanager](https://github.com/aws/aws-cdk/blob/main/packages/%40aws-cdk/aws-secretsmanager/README.md) for credentials rotation of existing clusters.
-
-## Audit and profiler Logs
-
-Sending audit or profiler needs to be configured in two places:
-
-1. Check / create the needed options in your ParameterGroup for [audit](https://docs.aws.amazon.com/documentdb/latest/developerguide/event-auditing.html#event-auditing-enabling-auditing) and
-[profiler](https://docs.aws.amazon.com/documentdb/latest/developerguide/profiling.html#profiling.enable-profiling) logs.
-2. Enable the corresponding option(s) when creating the `DatabaseCluster`:
-
-```ts
-import * as iam from 'aws-cdk-lib/aws-iam';
-import * as logs from'aws-cdk-lib/aws-logs';
-
-declare const myLogsPublishingRole: iam.Role;
-declare const vpc: ec2.Vpc;
-
-const cluster = new docdb.DatabaseCluster(this, 'Database', {
-  masterUser: {
-    username: 'myuser',
-  },
-  instanceType: ec2.InstanceType.of(ec2.InstanceClass.MEMORY5, ec2.InstanceSize.LARGE),
-  vpcSubnets: {
-    subnetType: ec2.SubnetType.PUBLIC,
-  },
-  vpc,
-  exportProfilerLogsToCloudWatch: true, // Enable sending profiler logs
-  exportAuditLogsToCloudWatch: true, // Enable sending audit logs
-  cloudWatchLogsRetention: logs.RetentionDays.THREE_MONTHS, // Optional - default is to never expire logs
-  cloudWatchLogsRetentionRole: myLogsPublishingRole, // Optional - a role will be created if not provided
-});
-```

package/iac/node_modules/aws-cdk-lib/aws-dynamodb/README.md

@@ -1,200 +0,0 @@
-# Amazon DynamoDB Construct Library
-
-
-Here is a minimal deployable DynamoDB table definition:
-
-```ts
-const table = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-});
-```
-
-## Importing existing tables
-
-To import an existing table into your CDK application, use the `Table.fromTableName`, `Table.fromTableArn` or `Table.fromTableAttributes`
-factory method. This method accepts table name or table ARN which describes the properties of an already
-existing table:
-
-```ts
-declare const user: iam.User;
-const table = dynamodb.Table.fromTableArn(this, 'ImportedTable', 'arn:aws:dynamodb:us-east-1:111111111:table/my-table');
-// now you can just call methods on the table
-table.grantReadWriteData(user);
-```
-
-If you intend to use the `tableStreamArn` (including indirectly, for example by creating an
-`@aws-cdk/aws-lambda-event-source.DynamoEventSource` on the imported table), you *must* use the
-`Table.fromTableAttributes` method and the `tableStreamArn` property *must* be populated.
-
-In order to grant permissions to indexes on imported tables you can either set `grantIndexPermissions` to `true`, or you can provide the indexes via the `globalIndexes` or `localIndexes` properties. This will enable `grant*` methods to also grant permissions to *all* table indexes.
-
-## Keys
-
-When a table is defined, you must define it's schema using the `partitionKey`
-(required) and `sortKey` (optional) properties.
-
-## Billing Mode
-
-DynamoDB supports two billing modes:
-
-* PROVISIONED - the default mode where the table and global secondary indexes have configured read and write capacity.
-* PAY_PER_REQUEST - on-demand pricing and scaling. You only pay for what you use and there is no read and write capacity for the table or its global secondary indexes.
-
-```ts
-const table = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
-});
-```
-
-Further reading:
-https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.ReadWriteCapacityMode.
-
-## Table Class
-
-DynamoDB supports two table classes:
-
-* STANDARD - the default mode, and is recommended for the vast majority of workloads.
-* STANDARD_INFREQUENT_ACCESS - optimized for tables where storage is the dominant cost.
-
-```ts
-const table = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  tableClass: dynamodb.TableClass.STANDARD_INFREQUENT_ACCESS,
-});
-```
-
-Further reading:
-https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.TableClasses.html
-
-## Configure AutoScaling for your table
-
-You can have DynamoDB automatically raise and lower the read and write capacities
-of your table by setting up autoscaling. You can use this to either keep your
-tables at a desired utilization level, or by scaling up and down at pre-configured
-times of the day:
-
-Auto-scaling is only relevant for tables with the billing mode, PROVISIONED.
-
-[Example of configuring autoscaling](test/integ.autoscaling.lit.ts)
-
-Further reading:
-https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/AutoScaling.html
-https://aws.amazon.com/blogs/database/how-to-use-aws-cloudformation-to-configure-auto-scaling-for-amazon-dynamodb-tables-and-indexes/
-
-## Amazon DynamoDB Global Tables
-
-You can create DynamoDB Global Tables by setting the `replicationRegions` property on a `Table`:
-
-```ts
-const globalTable = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  replicationRegions: ['us-east-1', 'us-east-2', 'us-west-2'],
-});
-```
-
-When doing so, a CloudFormation Custom Resource will be added to the stack in order to create the replica tables in the
-selected regions.
-
-The default billing mode for Global Tables is `PAY_PER_REQUEST`.
-If you want to use `PROVISIONED`,
-you have to make sure write auto-scaling is enabled for that Table:
-
-```ts
-const globalTable = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  replicationRegions: ['us-east-1', 'us-east-2', 'us-west-2'],
-  billingMode: dynamodb.BillingMode.PROVISIONED,
-});
-
-globalTable.autoScaleWriteCapacity({
-  minCapacity: 1,
-  maxCapacity: 10,
-}).scaleOnUtilization({ targetUtilizationPercent: 75 });
-```
-
-When adding a replica region for a large table, you might want to increase the
-timeout for the replication operation:
-
-```ts
-const globalTable = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  replicationRegions: ['us-east-1', 'us-east-2', 'us-west-2'],
-  replicationTimeout: Duration.hours(2), // defaults to Duration.minutes(30)
-});
-```
-
-## Encryption
-
-All user data stored in Amazon DynamoDB is fully encrypted at rest. When creating a new table, you can choose to encrypt using the following customer master keys (CMK) to encrypt your table:
-
-* AWS owned CMK - By default, all tables are encrypted under an AWS owned customer master key (CMK) in the DynamoDB service account (no additional charges apply).
-* AWS managed CMK - AWS KMS keys (one per region) are created in your account, managed, and used on your behalf by AWS DynamoDB (AWS KMS charges apply).
-* Customer managed CMK - You have full control over the KMS key used to encrypt the DynamoDB Table (AWS KMS charges apply).
-
-Creating a Table encrypted with a customer managed CMK:
-
-```ts
-const table = new dynamodb.Table(this, 'MyTable', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  encryption: dynamodb.TableEncryption.CUSTOMER_MANAGED,
-});
-
-// You can access the CMK that was added to the stack on your behalf by the Table construct via:
-const tableEncryptionKey = table.encryptionKey;
-```
-
-You can also supply your own key:
-
-```ts
-import * as kms from 'aws-cdk-lib/aws-kms';
-
-const encryptionKey = new kms.Key(this, 'Key', {
-  enableKeyRotation: true,
-});
-const table = new dynamodb.Table(this, 'MyTable', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  encryption: dynamodb.TableEncryption.CUSTOMER_MANAGED,
-  encryptionKey, // This will be exposed as table.encryptionKey
-});
-```
-
-In order to use the AWS managed CMK instead, change the code to:
-
-```ts
-const table = new dynamodb.Table(this, 'MyTable', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  encryption: dynamodb.TableEncryption.AWS_MANAGED,
-});
-
-// In this case, the CMK _cannot_ be accessed through table.encryptionKey.
-```
-
-## Get schema of table or secondary indexes
-
-To get the partition key and sort key of the table or indexes you have configured:
-
-```ts
-declare const table: dynamodb.Table;
-const schema = table.schema();
-const partitionKey = schema.partitionKey;
-const sortKey = schema.sortKey;
-
-// In case you want to get schema details for any secondary index
-// const { partitionKey, sortKey } = table.schema(INDEX_NAME);
-```
-
-## Kinesis Stream
-
-A Kinesis Data Stream can be configured on the DynamoDB table to capture item-level changes.
-
-```ts
-import * as kinesis from 'aws-cdk-lib/aws-kinesis';
-
-const stream = new kinesis.Stream(this, 'Stream');
-
-const table = new dynamodb.Table(this, 'Table', {
-  partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
-  kinesisStream: stream,
-});
-```