@aws-cdk/aws-ec2-alpha 2.156.0-alpha.0

package/lib/vpc-v2-base.js

@@ -0,0 +1,264 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VpcV2Base = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
+const util_1 = require("./util");
+const constructs_1 = require("constructs");
+/**
+ * Base class for creating a VPC (Virtual Private Cloud) in AWS.
+ *
+ * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.
+ */
+class VpcV2Base extends aws_cdk_lib_1.Resource {
+    constructor() {
+        super(...arguments);
+        /**
+        * List of public subnets in this VPC
+        */
+        this.publicSubnets = [];
+        /**
+        * List of private subnets in this VPC
+        */
+        this.privateSubnets = [];
+        /**
+        * AZs for this VPC
+        */
+        this.availabilityZones = [];
+        /**
+        * If this is set to true, don't error out on trying to select subnets
+        */
+        this.incompleteSubnetDefinition = false;
+    }
+    /**
+    * Return information on the subnets appropriate for the given selection strategy
+    *
+    * Requires that at least one subnet is matched, throws a descriptive
+    * error message otherwise.
+    */
+    selectSubnets(selection = {}) {
+        const subnets = this.selectSubnetObjects(selection);
+        const pubs = new Set(this.publicSubnets);
+        return {
+            subnetIds: subnets.map(s => s.subnetId),
+            get availabilityZones() { return subnets.map(s => s.availabilityZone); },
+            internetConnectivityEstablished: tap(new CompositeDependable(), d => subnets.forEach(s => d.add(s.internetConnectivityEstablished))),
+            subnets,
+            hasPublic: subnets.some(s => pubs.has(s)),
+            isPendingLookup: this.incompleteSubnetDefinition,
+        };
+    }
+    /**
+    * Adds a VPN Gateway to this VPC
+    */
+    enableVpnGateway(options) {
+        if (this.vpnGatewayId) {
+            throw new Error('The VPN Gateway has already been enabled.');
+        }
+        const vpnGateway = new aws_ec2_1.VpnGateway(this, 'VpnGateway', {
+            amazonSideAsn: options.amazonSideAsn,
+            type: aws_ec2_1.VpnConnectionType.IPSEC_1,
+        });
+        this._vpnGatewayId = vpnGateway.gatewayId;
+        const attachment = new aws_ec2_1.CfnVPCGatewayAttachment(this, 'VPCVPNGW', {
+            vpcId: this.vpcId,
+            vpnGatewayId: this._vpnGatewayId,
+        });
+        // Propagate routes on route tables associated with the right subnets
+        const vpnRoutePropagation = options.vpnRoutePropagation ?? [{}];
+        const routeTableIds = (0, util_1.allRouteTableIds)((0, util_1.flatten)(vpnRoutePropagation.map(s => this.selectSubnets(s).subnets)));
+        if (routeTableIds.length === 0) {
+            aws_cdk_lib_1.Annotations.of(this).addError(`enableVpnGateway: no subnets matching selection: '${JSON.stringify(vpnRoutePropagation)}'. Select other subnets to add routes to.`);
+        }
+        const routePropagation = new aws_ec2_1.CfnVPNGatewayRoutePropagation(this, 'RoutePropagation', {
+            routeTableIds,
+            vpnGatewayId: this._vpnGatewayId,
+        });
+        // The AWS::EC2::VPNGatewayRoutePropagation resource cannot use the VPN gateway
+        // until it has successfully attached to the VPC.
+        // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html
+        routePropagation.node.addDependency(attachment);
+    }
+    /**
+    * Adds a new VPN connection to this VPC
+    */
+    addVpnConnection(id, options) {
+        return new aws_ec2_1.VpnConnection(this, id, {
+            vpc: this,
+            ...options,
+        });
+    }
+    /**
+    * Adds a new client VPN endpoint to this VPC
+    */
+    addClientVpnEndpoint(id, options) {
+        return new aws_ec2_1.ClientVpnEndpoint(this, id, {
+            ...options,
+            vpc: this,
+        });
+    }
+    /**
+    * Adds a new interface endpoint to this VPC
+    */
+    addInterfaceEndpoint(id, options) {
+        return new aws_ec2_1.InterfaceVpcEndpoint(this, id, {
+            vpc: this,
+            ...options,
+        });
+    }
+    /**
+    * Adds a new gateway endpoint to this VPC
+    */
+    addGatewayEndpoint(id, options) {
+        return new aws_ec2_1.GatewayVpcEndpoint(this, id, {
+            vpc: this,
+            ...options,
+        });
+    }
+    /**
+    * Adds a new flow log to this VPC
+    */
+    addFlowLog(id, options) {
+        return new aws_ec2_1.FlowLog(this, id, {
+            resourceType: aws_ec2_1.FlowLogResourceType.fromVpc(this),
+            ...options,
+        });
+    }
+    /**
+    * Returns the id of the VPN Gateway (if enabled)
+    */
+    get vpnGatewayId() {
+        return this._vpnGatewayId;
+    }
+    /**
+    * Return the subnets appropriate for the placement strategy
+    */
+    selectSubnetObjects(selection = {}) {
+        selection = this.reifySelectionDefaults(selection);
+        if (selection.subnets !== undefined) {
+            return selection.subnets;
+        }
+        let subnets;
+        if (selection.subnetGroupName !== undefined) { // Select by name
+            subnets = this.selectSubnetObjectsByName(selection.subnetGroupName);
+        }
+        else { // Or specify by type
+            const type = selection.subnetType || aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS;
+            subnets = this.selectSubnetObjectsByType(type);
+        }
+        // Apply all the filters
+        subnets = this.applySubnetFilters(subnets, selection.subnetFilters ?? []);
+        return subnets;
+    }
+    applySubnetFilters(subnets, filters) {
+        let filtered = subnets;
+        // Apply each filter in sequence
+        for (const filter of filters) {
+            filtered = filter.selectSubnets(filtered);
+        }
+        return filtered;
+    }
+    selectSubnetObjectsByName(groupName) {
+        const allSubnets = [...this.publicSubnets, ...this.privateSubnets, ...this.isolatedSubnets];
+        const subnets = allSubnets.filter(s => (0, util_1.subnetGroupNameFromConstructId)(s) === groupName);
+        if (subnets.length === 0 && !this.incompleteSubnetDefinition) {
+            const names = Array.from(new Set(allSubnets.map(util_1.subnetGroupNameFromConstructId)));
+            throw new Error(`There are no subnet groups with name '${groupName}' in this VPC. Available names: ${names}`);
+        }
+        return subnets;
+    }
+    selectSubnetObjectsByType(subnetType) {
+        const allSubnets = {
+            [aws_ec2_1.SubnetType.PRIVATE_ISOLATED]: this.isolatedSubnets,
+            [aws_ec2_1.SubnetType.ISOLATED]: this.isolatedSubnets,
+            [aws_ec2_1.SubnetType.PRIVATE_WITH_NAT]: this.privateSubnets,
+            [aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS]: this.privateSubnets,
+            [aws_ec2_1.SubnetType.PRIVATE]: this.privateSubnets,
+            [aws_ec2_1.SubnetType.PUBLIC]: this.publicSubnets,
+        };
+        const subnets = allSubnets[subnetType];
+        // Force merge conflict here with https://github.com/aws/aws-cdk/pull/4089
+        // see ImportedVpc
+        if (subnets.length === 0 && !this.incompleteSubnetDefinition) {
+            const availableTypes = Object.entries(allSubnets).filter(([_, subs]) => subs.length > 0).map(([typeName, _]) => typeName);
+            throw new Error(`There are no '${subnetType}' subnet groups in this VPC. Available types: ${availableTypes}`);
+        }
+        return subnets;
+    }
+    /**
+    * Validate the fields in a SubnetSelection object, and reify defaults if necessary
+    *
+    * In case of default selection, select the first type of PRIVATE, ISOLATED,
+    * PUBLIC (in that order) that has any subnets.
+    */
+    reifySelectionDefaults(placement) {
+        // TODO: throw error as new VpcV2 cannot support subnetName or subnetGroupName anymore
+        if (placement.subnetName !== undefined) {
+            if (placement.subnetGroupName !== undefined) {
+                throw new Error('Please use only \'subnetGroupName\' (\'subnetName\' is deprecated and has the same behavior)');
+            }
+            else {
+                aws_cdk_lib_1.Annotations.of(this).addWarningV2('@aws-cdk/aws-ec2:subnetNameDeprecated', 'Usage of \'subnetName\' in SubnetSelection is deprecated, use \'subnetGroupName\' instead');
+            }
+            placement = { ...placement, subnetGroupName: placement.subnetName };
+        }
+        const exclusiveSelections = ['subnets', 'subnetType', 'subnetGroupName'];
+        const providedSelections = exclusiveSelections.filter(key => placement[key] !== undefined);
+        if (providedSelections.length > 1) {
+            throw new Error(`Only one of '${providedSelections}' can be supplied to subnet selection.`);
+        }
+        if (placement.subnetType === undefined && placement.subnetGroupName === undefined && placement.subnets === undefined) {
+            // Return default subnet type based on subnets that actually exist
+            let subnetType = this.privateSubnets.length
+                ? aws_ec2_1.SubnetType.PRIVATE_WITH_EGRESS : this.isolatedSubnets.length ? aws_ec2_1.SubnetType.PRIVATE_ISOLATED : aws_ec2_1.SubnetType.PUBLIC;
+            placement = { ...placement, subnetType: subnetType };
+        }
+        // Establish which subnet filters are going to be used
+        let subnetFilters = placement.subnetFilters ?? [];
+        // Backwards compatibility with existing `availabilityZones` and `onePerAz` functionality
+        if (placement.availabilityZones !== undefined) { // Filter by AZs, if specified
+            subnetFilters.push(aws_ec2_1.SubnetFilter.availabilityZones(placement.availabilityZones));
+        }
+        if (!!placement.onePerAz) { // Ensure one per AZ if specified
+            subnetFilters.push(aws_ec2_1.SubnetFilter.onePerAz());
+        }
+        // Overwrite the provided placement filters and remove the availabilityZones and onePerAz properties
+        placement = { ...placement, subnetFilters: subnetFilters, availabilityZones: undefined, onePerAz: undefined };
+        const { availabilityZones, onePerAz, ...rest } = placement;
+        return rest;
+    }
+}
+exports.VpcV2Base = VpcV2Base;
+_a = JSII_RTTI_SYMBOL_1;
+VpcV2Base[_a] = { fqn: "@aws-cdk/aws-ec2-alpha.VpcV2Base", version: "2.156.0-alpha.0" };
+class CompositeDependable {
+    constructor() {
+        this.dependables = new Array();
+        const self = this;
+        constructs_1.Dependable.implement(this, {
+            get dependencyRoots() {
+                const ret = new Array();
+                for (const dep of self.dependables) {
+                    ret.push(...constructs_1.Dependable.of(dep).dependencyRoots);
+                }
+                return ret;
+            },
+        });
+    }
+    /**
+    * Add a construct to the dependency roots
+    */
+    add(dep) {
+        this.dependables.push(dep);
+    }
+}
+/**
+* Invoke a function on a value (for its side effect) and return the value
+*/
+function tap(x, fn) {
+    fn(x);
+    return x;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpc-v2-base.js","sourceRoot":"","sources":["vpc-v2-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Resource, Annotations } from 'aws-cdk-lib';\nimport { IVpc, ISubnet, SubnetSelection, SelectedSubnets, EnableVpnGatewayOptions, VpnGateway, VpnConnectionType, CfnVPCGatewayAttachment, CfnVPNGatewayRoutePropagation, VpnConnectionOptions, VpnConnection, ClientVpnEndpointOptions, ClientVpnEndpoint, InterfaceVpcEndpointOptions, InterfaceVpcEndpoint, GatewayVpcEndpointOptions, GatewayVpcEndpoint, FlowLogOptions, FlowLog, FlowLogResourceType, SubnetType, SubnetFilter, CfnVPCCidrBlock } from 'aws-cdk-lib/aws-ec2';\nimport { allRouteTableIds, flatten, subnetGroupNameFromConstructId } from './util';\nimport { IDependable, Dependable, IConstruct } from 'constructs';\n\n/**\n * Placeholder to see what extra props we might need,\n * will be added to original IVPC\n */\nexport interface IVpcV2 extends IVpc {\n  /**\n   * The secondary CIDR blocks associated with the VPC.\n   *\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.\n   */\n  readonly secondaryCidrBlock: CfnVPCCidrBlock[];\n\n  /**\n   * The primary IPv4 CIDR block associated with the VPC.\n   * Needed in order to validate the vpc range of subnet\n   * current prop vpcCidrBlock refers to the token value\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-sizing-ipv4}.\n   */\n  readonly ipv4CidrBlock: string;\n\n}\n\n/**\n * Base class for creating a VPC (Virtual Private Cloud) in AWS.\n *\n * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.\n */\nexport abstract class VpcV2Base extends Resource implements IVpcV2 {\n\n  /**\n  * Identifier for this VPC\n  */\n  public abstract readonly vpcId: string;\n\n  /**\n  * Arn of this VPC\n  */\n  public abstract readonly vpcArn: string;\n\n  /**\n  * CIDR range for this VPC\n  */\n  public abstract readonly vpcCidrBlock: string;\n\n  /**\n  * List of public subnets in this VPC\n  */\n  public readonly publicSubnets: ISubnet[] = [];\n\n  /**\n  * List of private subnets in this VPC\n  */\n  public readonly privateSubnets: ISubnet[] = [];\n\n  /**\n  * List of isolated subnets in this VPC\n  */\n  public abstract readonly isolatedSubnets: ISubnet[];\n\n  /**\n  * AZs for this VPC\n  */\n  public readonly availabilityZones: string[] = [];\n\n  /**\n  * Dependable that can be depended upon to force internet connectivity established on the VPC\n  */\n  public abstract readonly internetConnectivityEstablished: IDependable;\n\n  /**\n   * Secondary IPs for the VPC, can be multiple Ipv4 or Ipv6\n   * Ipv4 should be within RFC#1918 range\n   */\n  public abstract readonly secondaryCidrBlock: CfnVPCCidrBlock[];\n\n  /**\n   * The primary IPv4 CIDR block associated with the VPC.\n   * Needed in order to validate the vpc range of subnet\n   * current prop vpcCidrBlock refers to the token value\n   * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-sizing-ipv4}.\n   */\n  public abstract readonly ipv4CidrBlock: string;\n\n  /**\n  * If this is set to true, don't error out on trying to select subnets\n  */\n  protected incompleteSubnetDefinition: boolean = false;\n\n  /**\n   * Mutable private field for the vpnGatewayId\n   *\n   * @internal\n   */\n  protected _vpnGatewayId?: string;\n\n  /**\n  * Return information on the subnets appropriate for the given selection strategy\n  *\n  * Requires that at least one subnet is matched, throws a descriptive\n  * error message otherwise.\n  */\n  public selectSubnets(selection: SubnetSelection = {}): SelectedSubnets {\n    const subnets = this.selectSubnetObjects(selection);\n    const pubs = new Set(this.publicSubnets);\n\n    return {\n      subnetIds: subnets.map(s => s.subnetId),\n      get availabilityZones(): string[] { return subnets.map(s => s.availabilityZone); },\n      internetConnectivityEstablished: tap(new CompositeDependable(), d => subnets.forEach(s => d.add(s.internetConnectivityEstablished))),\n      subnets,\n      hasPublic: subnets.some(s => pubs.has(s)),\n      isPendingLookup: this.incompleteSubnetDefinition,\n    };\n  }\n\n  /**\n  * Adds a VPN Gateway to this VPC\n  */\n  public enableVpnGateway(options: EnableVpnGatewayOptions): void {\n    if (this.vpnGatewayId) {\n      throw new Error('The VPN Gateway has already been enabled.');\n    }\n\n    const vpnGateway = new VpnGateway(this, 'VpnGateway', {\n      amazonSideAsn: options.amazonSideAsn,\n      type: VpnConnectionType.IPSEC_1,\n    });\n\n    this._vpnGatewayId = vpnGateway.gatewayId;\n\n    const attachment = new CfnVPCGatewayAttachment(this, 'VPCVPNGW', {\n      vpcId: this.vpcId,\n      vpnGatewayId: this._vpnGatewayId,\n    });\n\n    // Propagate routes on route tables associated with the right subnets\n    const vpnRoutePropagation = options.vpnRoutePropagation ?? [{}];\n    const routeTableIds = allRouteTableIds(flatten(vpnRoutePropagation.map(s => this.selectSubnets(s).subnets)));\n\n    if (routeTableIds.length === 0) {\n      Annotations.of(this).addError(`enableVpnGateway: no subnets matching selection: '${JSON.stringify(vpnRoutePropagation)}'. Select other subnets to add routes to.`);\n    }\n\n    const routePropagation = new CfnVPNGatewayRoutePropagation(this, 'RoutePropagation', {\n      routeTableIds,\n      vpnGatewayId: this._vpnGatewayId,\n    });\n      // The AWS::EC2::VPNGatewayRoutePropagation resource cannot use the VPN gateway\n      // until it has successfully attached to the VPC.\n      // See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpn-gatewayrouteprop.html\n    routePropagation.node.addDependency(attachment);\n  }\n\n  /**\n  * Adds a new VPN connection to this VPC\n  */\n  public addVpnConnection(id: string, options: VpnConnectionOptions): VpnConnection {\n    return new VpnConnection(this, id, {\n      vpc: this,\n      ...options,\n    });\n  }\n\n  /**\n  * Adds a new client VPN endpoint to this VPC\n  */\n  public addClientVpnEndpoint(id: string, options: ClientVpnEndpointOptions): ClientVpnEndpoint {\n    return new ClientVpnEndpoint(this, id, {\n      ...options,\n      vpc: this,\n    });\n  }\n\n  /**\n  * Adds a new interface endpoint to this VPC\n  */\n  public addInterfaceEndpoint(id: string, options: InterfaceVpcEndpointOptions): InterfaceVpcEndpoint {\n    return new InterfaceVpcEndpoint(this, id, {\n      vpc: this,\n      ...options,\n    });\n  }\n\n  /**\n  * Adds a new gateway endpoint to this VPC\n  */\n  public addGatewayEndpoint(id: string, options: GatewayVpcEndpointOptions): GatewayVpcEndpoint {\n    return new GatewayVpcEndpoint(this, id, {\n      vpc: this,\n      ...options,\n    });\n  }\n\n  /**\n  * Adds a new flow log to this VPC\n  */\n  public addFlowLog(id: string, options?: FlowLogOptions): FlowLog {\n    return new FlowLog(this, id, {\n      resourceType: FlowLogResourceType.fromVpc(this),\n      ...options,\n    });\n  }\n\n  /**\n  * Returns the id of the VPN Gateway (if enabled)\n  */\n  public get vpnGatewayId(): string | undefined {\n    return this._vpnGatewayId;\n  }\n\n  /**\n  * Return the subnets appropriate for the placement strategy\n  */\n  protected selectSubnetObjects(selection: SubnetSelection = {}): ISubnet[] {\n    selection = this.reifySelectionDefaults(selection);\n\n    if (selection.subnets !== undefined) {\n      return selection.subnets;\n    }\n\n    let subnets;\n\n    if (selection.subnetGroupName !== undefined) { // Select by name\n      subnets = this.selectSubnetObjectsByName(selection.subnetGroupName);\n\n    } else { // Or specify by type\n      const type = selection.subnetType || SubnetType.PRIVATE_WITH_EGRESS;\n      subnets = this.selectSubnetObjectsByType(type);\n    }\n\n    // Apply all the filters\n    subnets = this.applySubnetFilters(subnets, selection.subnetFilters ?? []);\n\n    return subnets;\n  }\n\n  private applySubnetFilters(subnets: ISubnet[], filters: SubnetFilter[]): ISubnet[] {\n    let filtered = subnets;\n    // Apply each filter in sequence\n    for (const filter of filters) {\n      filtered = filter.selectSubnets(filtered);\n    }\n    return filtered;\n  }\n\n  private selectSubnetObjectsByName(groupName: string) {\n    const allSubnets = [...this.publicSubnets, ...this.privateSubnets, ...this.isolatedSubnets];\n    const subnets = allSubnets.filter(s => subnetGroupNameFromConstructId(s) === groupName);\n\n    if (subnets.length === 0 && !this.incompleteSubnetDefinition) {\n      const names = Array.from(new Set(allSubnets.map(subnetGroupNameFromConstructId)));\n      throw new Error(`There are no subnet groups with name '${groupName}' in this VPC. Available names: ${names}`);\n    }\n\n    return subnets;\n  }\n\n  private selectSubnetObjectsByType(subnetType: SubnetType) {\n    const allSubnets = {\n      [SubnetType.PRIVATE_ISOLATED]: this.isolatedSubnets,\n      [SubnetType.ISOLATED]: this.isolatedSubnets,\n      [SubnetType.PRIVATE_WITH_NAT]: this.privateSubnets,\n      [SubnetType.PRIVATE_WITH_EGRESS]: this.privateSubnets,\n      [SubnetType.PRIVATE]: this.privateSubnets,\n      [SubnetType.PUBLIC]: this.publicSubnets,\n    };\n\n    const subnets = allSubnets[subnetType];\n\n    // Force merge conflict here with https://github.com/aws/aws-cdk/pull/4089\n    // see ImportedVpc\n\n    if (subnets.length === 0 && !this.incompleteSubnetDefinition) {\n      const availableTypes = Object.entries(allSubnets).filter(([_, subs]) => subs.length > 0).map(([typeName, _]) => typeName);\n      throw new Error(`There are no '${subnetType}' subnet groups in this VPC. Available types: ${availableTypes}`);\n    }\n\n    return subnets;\n  }\n\n  /**\n  * Validate the fields in a SubnetSelection object, and reify defaults if necessary\n  *\n  * In case of default selection, select the first type of PRIVATE, ISOLATED,\n  * PUBLIC (in that order) that has any subnets.\n  */\n  private reifySelectionDefaults(placement: SubnetSelection): SubnetSelection {\n\n    // TODO: throw error as new VpcV2 cannot support subnetName or subnetGroupName anymore\n    if (placement.subnetName !== undefined) {\n      if (placement.subnetGroupName !== undefined) {\n        throw new Error('Please use only \\'subnetGroupName\\' (\\'subnetName\\' is deprecated and has the same behavior)');\n      } else {\n        Annotations.of(this).addWarningV2('@aws-cdk/aws-ec2:subnetNameDeprecated', 'Usage of \\'subnetName\\' in SubnetSelection is deprecated, use \\'subnetGroupName\\' instead');\n      }\n      placement = { ...placement, subnetGroupName: placement.subnetName };\n    }\n\n    const exclusiveSelections: Array<keyof SubnetSelection> = ['subnets', 'subnetType', 'subnetGroupName'];\n    const providedSelections = exclusiveSelections.filter(key => placement[key] !== undefined);\n    if (providedSelections.length > 1) {\n      throw new Error(`Only one of '${providedSelections}' can be supplied to subnet selection.`);\n    }\n\n    if (placement.subnetType === undefined && placement.subnetGroupName === undefined && placement.subnets === undefined) {\n      // Return default subnet type based on subnets that actually exist\n      let subnetType = this.privateSubnets.length\n        ? SubnetType.PRIVATE_WITH_EGRESS : this.isolatedSubnets.length ? SubnetType.PRIVATE_ISOLATED : SubnetType.PUBLIC;\n      placement = { ...placement, subnetType: subnetType };\n    }\n\n    // Establish which subnet filters are going to be used\n    let subnetFilters = placement.subnetFilters ?? [];\n\n    // Backwards compatibility with existing `availabilityZones` and `onePerAz` functionality\n    if (placement.availabilityZones !== undefined) { // Filter by AZs, if specified\n      subnetFilters.push(SubnetFilter.availabilityZones(placement.availabilityZones));\n    }\n    if (!!placement.onePerAz) { // Ensure one per AZ if specified\n      subnetFilters.push(SubnetFilter.onePerAz());\n    }\n\n    // Overwrite the provided placement filters and remove the availabilityZones and onePerAz properties\n    placement = { ...placement, subnetFilters: subnetFilters, availabilityZones: undefined, onePerAz: undefined };\n    const { availabilityZones, onePerAz, ...rest } = placement;\n\n    return rest;\n  }\n\n}\n\nclass CompositeDependable implements IDependable {\n  private readonly dependables = new Array<IDependable>();\n\n  constructor() {\n    const self = this;\n    Dependable.implement(this, {\n      get dependencyRoots() {\n        const ret = new Array<IConstruct>();\n        for (const dep of self.dependables) {\n          ret.push(...Dependable.of(dep).dependencyRoots);\n        }\n        return ret;\n      },\n    });\n  }\n\n  /**\n  * Add a construct to the dependency roots\n  */\n  public add(dep: IDependable) {\n    this.dependables.push(dep);\n  }\n}\n\n/**\n* Invoke a function on a value (for its side effect) and return the value\n*/\nfunction tap<T>(x: T, fn: (x: T) => void): T {\n  fn(x);\n  return x;\n\n}"]}

package/lib/vpc-v2.d.ts

@@ -0,0 +1,222 @@
+import { CfnVPC, CfnVPCCidrBlock, DefaultInstanceTenancy, ISubnet } from 'aws-cdk-lib/aws-ec2';
+import { CfnResource } from 'aws-cdk-lib/core';
+import { Construct, IDependable } from 'constructs';
+import { IpamOptions, IIpamPool } from './ipam';
+import { VpcV2Base } from './vpc-v2-base';
+/**
+ * Additional props needed for secondary Address
+ */
+export interface SecondaryAddressProps {
+    /**
+     * Required to set Secondary cidr block resource name
+     * in order to generate unique logical id for the resource.
+     */
+    readonly cidrBlockName: string;
+}
+/**
+ * IpAddress options to define VPC V2
+ */
+export declare class IpAddresses {
+    /**
+     * An IPv4 CIDR Range
+     */
+    static ipv4(ipv4Cidr: string, props?: SecondaryAddressProps): IIpAddresses;
+    /**
+     * An Ipv4 Ipam Pool
+     */
+    static ipv4Ipam(ipv4IpamOptions: IpamOptions): IIpAddresses;
+    /**
+     * An Ipv6 Ipam Pool
+     */
+    static ipv6Ipam(ipv6IpamOptions: IpamOptions): IIpAddresses;
+    /**
+     * Amazon Provided Ipv6 range
+     */
+    static amazonProvidedIpv6(props: SecondaryAddressProps): IIpAddresses;
+}
+/**
+ * Consolidated return parameters to pass to VPC construct
+ */
+export interface VpcCidrOptions {
+    /**
+     * IPv4 CIDR Block
+     * @default - '10.0.0.0/16'
+     */
+    readonly ipv4CidrBlock?: string;
+    /**
+     * CIDR Mask for Vpc
+     *
+     * @default - Only required when using IPAM Ipv4
+     */
+    readonly ipv4NetmaskLength?: number;
+    /**
+     * Ipv4 IPAM Pool
+     *
+     * @default - Only required when using IPAM Ipv4
+     */
+    readonly ipv4IpamPool?: IIpamPool;
+    /**
+     * Implementing Ipv6
+     * @default - No ipv6 address
+     */
+    readonly ipv6CidrBlock?: string;
+    /**
+     * CIDR Mask for Vpc
+     *
+     * @default - Only required when using AWS Ipam
+     */
+    readonly ipv6NetmaskLength?: number;
+    /**
+     * Ipv6 IPAM pool id for VPC range, can only be defined
+     * under public scope
+     *
+     * @default - no pool id
+     */
+    readonly ipv6IpamPool?: IIpamPool;
+    /**
+     * Use amazon provided IP range
+     * @default false
+     */
+    readonly amazonProvided?: boolean;
+    /**
+     * Dependency to associate Ipv6 CIDR block
+     * @default - No dependency
+     */
+    readonly dependencies?: CfnResource[];
+    /**
+     * Required to set Secondary cidr block resource name
+     * in order to generate unique logical id for the resource.
+     * @default : no name for primary addresses
+     */
+    readonly cidrBlockName?: string;
+}
+/**
+ * Implements ip address allocation according to the IPAdress type
+ */
+export interface IIpAddresses {
+    /**
+     * Method to define the implementation logic of
+     * IP address allocation
+     */
+    allocateVpcCidr(): VpcCidrOptions;
+}
+/**
+ * Properties to define VPC
+ * [disable-awslint:from-method]
+ */
+export interface VpcV2Props {
+    /** A must IPv4 CIDR block for the VPC
+     * https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html
+     * @default - Ipv4 CIDR Block ('10.0.0.0/16')
+    */
+    readonly primaryAddressBlock?: IIpAddresses;
+    /**
+     * The secondary CIDR blocks associated with the VPC.
+     * Can be  IPv4 or IPv6, two IPv4 ranges must follow RFC#1918 convention
+     * For more information, see the {@link https://docs.aws.amazon.com/vpc/latest/userguide/vpc-cidr-blocks.html#vpc-resize}.
+     * @default - No secondary IP address
+    */
+    readonly secondaryAddressBlocks?: IIpAddresses[];
+    /**
+     * Indicates whether the instances launched in the VPC get DNS hostnames
+     * @default true
+     */
+    readonly enableDnsHostnames?: boolean;
+    /**
+     * Indicates whether the DNS resolution is supported for the VPC.
+     * @default true
+     */
+    readonly enableDnsSupport?: boolean;
+    /**
+     * The default tenancy of instances launched into the VPC.
+     *
+     * By setting this to dedicated tenancy, instances will be launched on
+     * hardware dedicated to a single AWS customer, unless specifically specified
+     * at instance launch time. Please note, not all instance types are usable
+     * with Dedicated tenancy.
+     *
+     * @default DefaultInstanceTenancy.Default (shared) tenancy
+     */
+    readonly defaultInstanceTenancy?: DefaultInstanceTenancy;
+    /**
+     * Physical name for the VPC
+     * @default: autogenerated by CDK
+     */
+    readonly vpcName?: string;
+}
+/**
+ * This class provides a foundation for creating and configuring a VPC with advanced features such as IPAM (IP Address Management) and IPv6 support.
+ *
+ * For more information, see the {@link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.Vpc.html|AWS CDK Documentation on VPCs}.
+ *
+ * @resource AWS::EC2::VPC
+ */
+export declare class VpcV2 extends VpcV2Base {
+    /**
+     * Identifier for this VPC
+     */
+    readonly vpcId: string;
+    /**
+    * @attribute
+    */
+    readonly vpcArn: string;
+    /**
+     * @attribute
+    */
+    readonly vpcCidrBlock: string;
+    /**
+     * The IPv6 CIDR blocks for the VPC.
+     *
+     * See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpc.html#aws-resource-ec2-vpc-return-values
+     */
+    readonly ipv6CidrBlocks: string[];
+    /**
+     * The provider of ipv4 addresses
+     */
+    readonly ipAddresses: IIpAddresses;
+    /**
+     * The AWS CloudFormation resource representing the VPC.
+     */
+    readonly resource: CfnVPC;
+    /**
+     * Indicates if instances launched in this VPC will have public DNS hostnames.
+     */
+    readonly dnsHostnamesEnabled: boolean;
+    /**
+    * Indicates if DNS support is enabled for this VPC.
+    */
+    readonly dnsSupportEnabled: boolean;
+    /**
+     * Isolated Subnets that are part of this VPC.
+     */
+    readonly isolatedSubnets: ISubnet[];
+    /**
+     * Public Subnets that are part of this VPC.
+     */
+    readonly publicSubnets: ISubnet[];
+    /**
+     * Pbulic Subnets that are part of this VPC.
+     */
+    readonly privateSubnets: ISubnet[];
+    /**
+     * To define dependency on internet connectivity
+     */
+    readonly internetConnectivityEstablished: IDependable;
+    /**
+     * To define dependency on internet connectivity
+     */
+    private readonly _internetConnectivityEstablished;
+    /**
+   * reference to all secondary blocks attached
+   */
+    readonly secondaryCidrBlock: CfnVPCCidrBlock[];
+    /**
+     * For validation to define IPv6 subnets, set to true in case of
+     * Amazon Provided IPv6 cidr range
+     * IPv6 addresses can be attached to the subnets
+     * @default false
+     */
+    readonly useIpv6: boolean;
+    readonly ipv4CidrBlock: string;
+    constructor(scope: Construct, id: string, props?: VpcV2Props);
+}