fix(docdb): make most attributes of DatabaseClusterAttributes optional (#19625)

Fixes #14492

- Test Result
```
❯ yarn test
yarn run v1.22.17
$ cdk-test
PASS test/endpoint.test.js (17.557 s)
PASS test/parameter-group.test.js (17.601 s)
PASS test/instance.test.js (18.16 s)
PASS test/cluster.test.js (19.233 s)

 

=============================== Coverage summary ===============================
Statements   : 98.76% ( 160/162 )
Branches     : 99.02% ( 102/103 )
Functions    : 100% ( 27/27 )
Lines        : 98.75% ( 158/160 )
================================================================================

 

Test Suites: 4 passed, 4 total
Tests:       51 passed, 51 total
Snapshots:   0 total
Time:        19.946 s
Ran all test suites.
Verifying integ.cluster-rotation.lit.js against integ.cluster-rotation.lit.expected.json ... OK.
Verifying integ.cluster.js against integ.cluster.expected.json ... OK.
Tests successful. Total time (26.2s) | /Users/yoshitaka.koitabashi/Desktop/OSS/tmp/aws-cdk/node_modules/jest/bin/jest.js (23.8s) | cdk-integ-assert (2.4s)
✨  Done in 26.72s.
```
----

### All Submissions:

* [ ] Have you followed the guidelines in our [Contributing guide?](https://github.com/aws/aws-cdk/blob/master/CONTRIBUTING.md)

### Adding new Unconventional Dependencies:

* [ ] This PR adds new unconventional dependencies following the process described [here](https://github.com/aws/aws-cdk/blob/master/CONTRIBUTING.md/#adding-new-unconventional-dependencies)

### New Features

* [ ] Have you added the new feature to an [integration test](https://github.com/aws/aws-cdk/blob/master/INTEGRATION_TESTS.md)?
	* [ ] Did you use `cdk-integ` to deploy the infrastructure and generate the snapshot (i.e. `cdk-integ` without `--dry-run`)?

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

Author: Synohara

packages/@aws-cdk/aws-docdb/lib/cluster-ref.ts

@@ -46,13 +46,15 @@ export interface IDatabaseCluster extends IResource, IConnectable, ISecretAttach
 export interface DatabaseClusterAttributes {
   /**
    * The database port
+   * @default - none
    */
-  readonly port: number;
+  readonly port?: number;
 
   /**
    * The security group of the database cluster
+   * @default - no security groups
    */
-  readonly securityGroup: ISecurityGroup;
+  readonly securityGroup?: ISecurityGroup;
 
   /**
    * Identifier for the cluster
@@ -61,22 +63,26 @@ export interface DatabaseClusterAttributes {
 
   /**
    * Identifier for the instances
+   * @default - no instance identifiers
    */
-  readonly instanceIdentifiers: string[];
+  readonly instanceIdentifiers?: string[];
   // Actual underlying type: DBInstanceId[], but we have to type it more loosely for Java's benefit.
 
   /**
    * Cluster endpoint address
+   * @default - no cluster endpoint address
    */
-  readonly clusterEndpointAddress: string;
+  readonly clusterEndpointAddress?: string;
 
   /**
    * Reader endpoint address
+   * @default - no reader endpoint address
    */
-  readonly readerEndpointAddress: string;
+  readonly readerEndpointAddress?: string;
 
   /**
    * Endpoint addresses of individual instances
+   * @default - no instance endpoint addresses
    */
-  readonly instanceEndpointAddresses: string[];
+  readonly instanceEndpointAddresses?: string[];
 }

packages/@aws-cdk/aws-docdb/lib/cluster.ts

@@ -257,17 +257,55 @@ export class DatabaseCluster extends DatabaseClusterBase {
    */
   public static fromDatabaseClusterAttributes(scope: Construct, id: string, attrs: DatabaseClusterAttributes): IDatabaseCluster {
     class Import extends DatabaseClusterBase implements IDatabaseCluster {
-      public readonly defaultPort = ec2.Port.tcp(attrs.port);
+      public readonly defaultPort = typeof attrs.port !== 'undefined' ? ec2.Port.tcp(attrs.port) : undefined;
       public readonly connections = new ec2.Connections({
-        securityGroups: [attrs.securityGroup],
+        securityGroups: attrs.securityGroup ? [attrs.securityGroup] : undefined,
         defaultPort: this.defaultPort,
       });
       public readonly clusterIdentifier = attrs.clusterIdentifier;
-      public readonly instanceIdentifiers = attrs.instanceIdentifiers;
-      public readonly clusterEndpoint = new Endpoint(attrs.clusterEndpointAddress, attrs.port);
-      public readonly clusterReadEndpoint = new Endpoint(attrs.readerEndpointAddress, attrs.port);
-      public readonly instanceEndpoints = attrs.instanceEndpointAddresses.map(a => new Endpoint(a, attrs.port));
-      public readonly securityGroupId = attrs.securityGroup.securityGroupId;
+      private readonly _instanceIdentifiers = attrs.instanceIdentifiers;
+      private readonly _clusterEndpoint = attrs.clusterEndpointAddress && typeof attrs.port !== 'undefined' ?
+        new Endpoint(attrs.clusterEndpointAddress, attrs.port) : undefined;
+      private readonly _clusterReadEndpoint = attrs.readerEndpointAddress && typeof attrs.port !== 'undefined' ?
+        new Endpoint(attrs.readerEndpointAddress, attrs.port) : undefined;
+      private readonly _instanceEndpoints = attrs.instanceEndpointAddresses && typeof attrs.port !== 'undefined' ?
+        attrs.instanceEndpointAddresses.map(addr => new Endpoint(addr, attrs.port!)) : undefined;
+      private readonly _securityGroupId = attrs.securityGroup?.securityGroupId;
+
+      public get instanceIdentifiers(): string[] {
+        if (!this._instanceIdentifiers) {
+          throw new Error('Cannot access `instanceIdentifiers` of an imported cluster without provided instanceIdentifiers');
+        }
+        return this._instanceIdentifiers;
+      }
+
+      public get clusterEndpoint(): Endpoint {
+        if (!this._clusterEndpoint) {
+          throw new Error('Cannot access `clusterEndpoint` of an imported cluster without an endpoint address and port');
+        }
+        return this._clusterEndpoint;
+      }
+
+      public get clusterReadEndpoint(): Endpoint {
+        if (!this._clusterReadEndpoint) {
+          throw new Error('Cannot access `clusterReadEndpoint` of an imported cluster without a readerEndpointAddress and port');
+        }
+        return this._clusterReadEndpoint;
+      }
+
+      public get instanceEndpoints(): Endpoint[] {
+        if (!this._instanceEndpoints) {
+          throw new Error('Cannot access `instanceEndpoints` of an imported cluster without instanceEndpointAddresses and port');
+        }
+        return this._instanceEndpoints;
+      }
+
+      public get securityGroupId(): string {
+        if (!this._securityGroupId) {
+          throw new Error('Cannot access `securityGroupId` of an imported cluster without securityGroupId');
+        }
+        return this._securityGroupId;
+      }
     }
 
     return new Import(scope, id);

packages/@aws-cdk/aws-docdb/test/cluster.test.ts

@@ -518,6 +518,21 @@ describe('DatabaseCluster', () => {
     });
   });
 
+  test('minimal imported cluster throws on accessing attributes for unprovided parameters', () => {
+    const stack = testStack();
+
+    const cluster = DatabaseCluster.fromDatabaseClusterAttributes(stack, 'Database', {
+      clusterIdentifier: 'identifier',
+    });
+
+    expect(cluster.clusterIdentifier).toEqual('identifier');
+    expect(() => cluster.clusterEndpoint).toThrow(/Cannot access `clusterEndpoint` of an imported cluster/);
+    expect(() => cluster.clusterReadEndpoint).toThrow(/Cannot access `clusterReadEndpoint` of an imported cluster/);
+    expect(() => cluster.instanceIdentifiers).toThrow(/Cannot access `instanceIdentifiers` of an imported cluster/);
+    expect(() => cluster.instanceEndpoints).toThrow(/Cannot access `instanceEndpoints` of an imported cluster/);
+    expect(() => cluster.securityGroupId).toThrow(/Cannot access `securityGroupId` of an imported cluster/);
+  });
+
   test('backup retention period respected', () => {
     // GIVEN
     const stack = testStack();