aws-cdk 0.0.0

package/lib/context-providers/vpcs.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VpcNetworkContextProviderPlugin = void 0;
+const cx_api_1 = require("@aws-cdk/cx-api");
+const sdk_provider_1 = require("../api/aws-auth/sdk-provider");
+const logging_1 = require("../logging");
+const error_1 = require("../toolkit/error");
+class VpcNetworkContextProviderPlugin {
+    constructor(aws) {
+        this.aws = aws;
+    }
+    async getValue(args) {
+        const ec2 = (await (0, sdk_provider_1.initContextProviderSdk)(this.aws, args)).ec2();
+        const vpcId = await this.findVpc(ec2, args);
+        return this.readVpcProps(ec2, vpcId, args);
+    }
+    async findVpc(ec2, args) {
+        // Build request filter (map { Name -> Value } to list of [{ Name, Values }])
+        const filters = Object.entries(args.filter).map(([tag, value]) => ({ Name: tag, Values: [value] }));
+        (0, logging_1.debug)(`Listing VPCs in ${args.account}:${args.region}`);
+        const response = await ec2.describeVpcs({ Filters: filters });
+        const vpcs = response.Vpcs || [];
+        if (vpcs.length === 0) {
+            throw new error_1.ContextProviderError(`Could not find any VPCs matching ${JSON.stringify(args)}`);
+        }
+        if (vpcs.length > 1) {
+            throw new error_1.ContextProviderError(`Found ${vpcs.length} VPCs matching ${JSON.stringify(args)}; please narrow the search criteria`);
+        }
+        return vpcs[0];
+    }
+    async readVpcProps(ec2, vpc, args) {
+        var _a, _b;
+        const vpcId = vpc.VpcId;
+        (0, logging_1.debug)(`Describing VPC ${vpcId}`);
+        const filters = { Filters: [{ Name: 'vpc-id', Values: [vpcId] }] };
+        const subnetsResponse = await ec2.describeSubnets(filters);
+        const listedSubnets = subnetsResponse.Subnets || [];
+        const routeTablesResponse = await ec2.describeRouteTables(filters);
+        const routeTables = new RouteTables(routeTablesResponse.RouteTables || []);
+        // Now comes our job to separate these subnets out into AZs and subnet groups (Public, Private, Isolated)
+        // We have the following attributes to go on:
+        // - Type tag, we tag subnets with their type. In absence of this tag, we
+        //   determine the subnet must be Public if either:
+        //   a) it has the property MapPublicIpOnLaunch
+        //   b) it has a route to an Internet Gateway
+        //   If both of the above is false but the subnet has a route to a NAT Gateway
+        //   and the destination CIDR block is "0.0.0.0/0", we assume it to be a Private subnet.
+        //   Anything else is considered Isolated.
+        // - Name tag, we tag subnets with their subnet group name. In absence of this tag,
+        //   we use the type as the name.
+        const azs = Array.from(new Set(listedSubnets.map((s) => s.AvailabilityZone)));
+        azs.sort();
+        const subnets = listedSubnets.map((subnet) => {
+            let type = getTag('aws-cdk:subnet-type', subnet.Tags);
+            if (type === undefined && subnet.MapPublicIpOnLaunch) {
+                type = SubnetType.Public;
+            }
+            if (type === undefined && routeTables.hasRouteToIgw(subnet.SubnetId)) {
+                type = SubnetType.Public;
+            }
+            if (type === undefined && routeTables.hasRouteToNatGateway(subnet.SubnetId)) {
+                type = SubnetType.Private;
+            }
+            if (type === undefined && routeTables.hasRouteToTransitGateway(subnet.SubnetId)) {
+                type = SubnetType.Private;
+            }
+            if (type === undefined) {
+                type = SubnetType.Isolated;
+            }
+            if (!isValidSubnetType(type)) {
+                // eslint-disable-next-line max-len
+                throw new error_1.ContextProviderError(`Subnet ${subnet.SubnetArn} has invalid subnet type ${type} (must be ${SubnetType.Public}, ${SubnetType.Private} or ${SubnetType.Isolated})`);
+            }
+            if (args.subnetGroupNameTag && !getTag(args.subnetGroupNameTag, subnet.Tags)) {
+                throw new error_1.ContextProviderError(`Invalid subnetGroupNameTag: Subnet ${subnet.SubnetArn} does not have an associated tag with Key='${args.subnetGroupNameTag}'`);
+            }
+            const name = getTag(args.subnetGroupNameTag || 'aws-cdk:subnet-name', subnet.Tags) || type;
+            const routeTableId = routeTables.routeTableIdForSubnetId(subnet.SubnetId);
+            if (!routeTableId) {
+                throw new error_1.ContextProviderError(`Subnet ${subnet.SubnetArn} does not have an associated route table (and there is no "main" table)`);
+            }
+            return {
+                az: subnet.AvailabilityZone,
+                cidr: subnet.CidrBlock,
+                type,
+                name,
+                subnetId: subnet.SubnetId,
+                routeTableId,
+            };
+        });
+        let grouped;
+        let assymetricSubnetGroups;
+        if (args.returnAsymmetricSubnets) {
+            grouped = { azs: [], groups: [] };
+            assymetricSubnetGroups = groupAsymmetricSubnets(subnets);
+        }
+        else {
+            grouped = groupSubnets(subnets);
+            assymetricSubnetGroups = undefined;
+        }
+        // Find attached+available VPN gateway for this VPC
+        const vpnGatewayResponse = ((_a = args.returnVpnGateways) !== null && _a !== void 0 ? _a : true)
+            ? await ec2.describeVpnGateways({
+                Filters: [
+                    {
+                        Name: 'attachment.vpc-id',
+                        Values: [vpcId],
+                    },
+                    {
+                        Name: 'attachment.state',
+                        Values: ['attached'],
+                    },
+                    {
+                        Name: 'state',
+                        Values: ['available'],
+                    },
+                ],
+            })
+            : undefined;
+        const vpnGatewayId = ((_b = vpnGatewayResponse === null || vpnGatewayResponse === void 0 ? void 0 : vpnGatewayResponse.VpnGateways) === null || _b === void 0 ? void 0 : _b.length) === 1 ? vpnGatewayResponse.VpnGateways[0].VpnGatewayId : undefined;
+        return {
+            vpcId,
+            vpcCidrBlock: vpc.CidrBlock,
+            ownerAccountId: vpc.OwnerId,
+            availabilityZones: grouped.azs,
+            isolatedSubnetIds: collapse(flatMap(findGroups(SubnetType.Isolated, grouped), (group) => group.subnets.map((s) => s.subnetId))),
+            isolatedSubnetNames: collapse(flatMap(findGroups(SubnetType.Isolated, grouped), (group) => (group.name ? [group.name] : []))),
+            isolatedSubnetRouteTableIds: collapse(flatMap(findGroups(SubnetType.Isolated, grouped), (group) => group.subnets.map((s) => s.routeTableId))),
+            privateSubnetIds: collapse(flatMap(findGroups(SubnetType.Private, grouped), (group) => group.subnets.map((s) => s.subnetId))),
+            privateSubnetNames: collapse(flatMap(findGroups(SubnetType.Private, grouped), (group) => (group.name ? [group.name] : []))),
+            privateSubnetRouteTableIds: collapse(flatMap(findGroups(SubnetType.Private, grouped), (group) => group.subnets.map((s) => s.routeTableId))),
+            publicSubnetIds: collapse(flatMap(findGroups(SubnetType.Public, grouped), (group) => group.subnets.map((s) => s.subnetId))),
+            publicSubnetNames: collapse(flatMap(findGroups(SubnetType.Public, grouped), (group) => (group.name ? [group.name] : []))),
+            publicSubnetRouteTableIds: collapse(flatMap(findGroups(SubnetType.Public, grouped), (group) => group.subnets.map((s) => s.routeTableId))),
+            vpnGatewayId,
+            subnetGroups: assymetricSubnetGroups,
+        };
+    }
+}
+exports.VpcNetworkContextProviderPlugin = VpcNetworkContextProviderPlugin;
+class RouteTables {
+    constructor(tables) {
+        this.tables = tables;
+        this.mainRouteTable = this.tables.find((table) => !!table.Associations && table.Associations.some((assoc) => !!assoc.Main));
+    }
+    routeTableIdForSubnetId(subnetId) {
+        const table = this.tableForSubnet(subnetId);
+        return (table && table.RouteTableId) || (this.mainRouteTable && this.mainRouteTable.RouteTableId);
+    }
+    /**
+     * Whether the given subnet has a route to a NAT Gateway
+     */
+    hasRouteToNatGateway(subnetId) {
+        const table = this.tableForSubnet(subnetId) || this.mainRouteTable;
+        return (!!table &&
+            !!table.Routes &&
+            table.Routes.some((route) => !!route.NatGatewayId && route.DestinationCidrBlock === '0.0.0.0/0'));
+    }
+    /**
+     * Whether the given subnet has a route to a Transit Gateway
+     */
+    hasRouteToTransitGateway(subnetId) {
+        const table = this.tableForSubnet(subnetId) || this.mainRouteTable;
+        return (!!table &&
+            !!table.Routes &&
+            table.Routes.some((route) => !!route.TransitGatewayId && route.DestinationCidrBlock === '0.0.0.0/0'));
+    }
+    /**
+     * Whether the given subnet has a route to an IGW
+     */
+    hasRouteToIgw(subnetId) {
+        const table = this.tableForSubnet(subnetId) || this.mainRouteTable;
+        return (!!table && !!table.Routes && table.Routes.some((route) => !!route.GatewayId && route.GatewayId.startsWith('igw-')));
+    }
+    tableForSubnet(subnetId) {
+        return this.tables.find((table) => !!table.Associations && table.Associations.some((assoc) => assoc.SubnetId === subnetId));
+    }
+}
+/**
+ * Return the value of a tag from a set of tags
+ */
+function getTag(name, tags) {
+    for (const tag of tags || []) {
+        if (tag.Key === name) {
+            return tag.Value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Group subnets of the same type together, and order by AZ
+ */
+function groupSubnets(subnets) {
+    const grouping = {};
+    for (const subnet of subnets) {
+        const key = [subnet.type, subnet.name].toString();
+        if (!(key in grouping)) {
+            grouping[key] = [];
+        }
+        grouping[key].push(subnet);
+    }
+    const groups = Object.values(grouping).map((sns) => {
+        sns.sort((a, b) => a.az.localeCompare(b.az));
+        return {
+            type: sns[0].type,
+            name: sns[0].name,
+            subnets: sns,
+        };
+    });
+    const azs = groups[0].subnets.map((s) => s.az);
+    for (const group of groups) {
+        const groupAZs = group.subnets.map((s) => s.az);
+        if (!arraysEqual(groupAZs, azs)) {
+            throw new error_1.ContextProviderError(`Not all subnets in VPC have the same AZs: ${groupAZs} vs ${azs}`);
+        }
+    }
+    return { azs, groups };
+}
+function groupAsymmetricSubnets(subnets) {
+    const grouping = {};
+    for (const subnet of subnets) {
+        const key = [subnet.type, subnet.name].toString();
+        if (!(key in grouping)) {
+            grouping[key] = [];
+        }
+        grouping[key].push(subnet);
+    }
+    return Object.values(grouping).map((subnetArray) => {
+        subnetArray.sort((subnet1, subnet2) => subnet1.az.localeCompare(subnet2.az));
+        return {
+            name: subnetArray[0].name,
+            type: subnetTypeToVpcSubnetType(subnetArray[0].type),
+            subnets: subnetArray.map((subnet) => ({
+                subnetId: subnet.subnetId,
+                cidr: subnet.cidr,
+                availabilityZone: subnet.az,
+                routeTableId: subnet.routeTableId,
+            })),
+        };
+    });
+}
+function subnetTypeToVpcSubnetType(type) {
+    switch (type) {
+        case SubnetType.Isolated:
+            return cx_api_1.VpcSubnetGroupType.ISOLATED;
+        case SubnetType.Private:
+            return cx_api_1.VpcSubnetGroupType.PRIVATE;
+        case SubnetType.Public:
+            return cx_api_1.VpcSubnetGroupType.PUBLIC;
+    }
+}
+var SubnetType;
+(function (SubnetType) {
+    SubnetType["Public"] = "Public";
+    SubnetType["Private"] = "Private";
+    SubnetType["Isolated"] = "Isolated";
+})(SubnetType || (SubnetType = {}));
+function isValidSubnetType(val) {
+    return val === SubnetType.Public || val === SubnetType.Private || val === SubnetType.Isolated;
+}
+function arraysEqual(as, bs) {
+    if (as.length !== bs.length) {
+        return false;
+    }
+    for (let i = 0; i < as.length; i++) {
+        if (as[i] !== bs[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function findGroups(type, groups) {
+    return groups.groups.filter((g) => g.type === type);
+}
+function flatMap(xs, fn) {
+    const ret = new Array();
+    for (const x of xs) {
+        ret.push(...fn(x));
+    }
+    return ret;
+}
+function collapse(xs) {
+    if (xs.length > 0) {
+        return xs;
+    }
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vpcs.js","sourceRoot":"","sources":["vpcs.ts"],"names":[],"mappings":"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","sourcesContent":["import type { VpcContextQuery } from '@aws-cdk/cloud-assembly-schema';\nimport { type VpcContextResponse, type VpcSubnetGroup, VpcSubnetGroupType } from '@aws-cdk/cx-api';\nimport type { Filter, RouteTable, Tag, Vpc } from '@aws-sdk/client-ec2';\nimport type { IEC2Client } from '../api';\nimport { type SdkProvider, initContextProviderSdk } from '../api/aws-auth/sdk-provider';\nimport { ContextProviderPlugin } from '../api/plugin';\nimport { debug } from '../logging';\nimport { ContextProviderError } from '../toolkit/error';\nexport class VpcNetworkContextProviderPlugin implements ContextProviderPlugin {\n  constructor(private readonly aws: SdkProvider) {}\n\n  public async getValue(args: VpcContextQuery) {\n    const ec2 = (await initContextProviderSdk(this.aws, args)).ec2();\n\n    const vpcId = await this.findVpc(ec2, args);\n\n    return this.readVpcProps(ec2, vpcId, args);\n  }\n\n  private async findVpc(ec2: IEC2Client, args: VpcContextQuery): Promise<Vpc> {\n    // Build request filter (map { Name -> Value } to list of [{ Name, Values }])\n    const filters: Filter[] = Object.entries(args.filter).map(([tag, value]) => ({ Name: tag, Values: [value] }));\n\n    debug(`Listing VPCs in ${args.account}:${args.region}`);\n    const response = await ec2.describeVpcs({ Filters: filters });\n\n    const vpcs = response.Vpcs || [];\n    if (vpcs.length === 0) {\n      throw new ContextProviderError(`Could not find any VPCs matching ${JSON.stringify(args)}`);\n    }\n    if (vpcs.length > 1) {\n      throw new ContextProviderError(`Found ${vpcs.length} VPCs matching ${JSON.stringify(args)}; please narrow the search criteria`);\n    }\n\n    return vpcs[0];\n  }\n\n  private async readVpcProps(ec2: IEC2Client, vpc: Vpc, args: VpcContextQuery): Promise<VpcContextResponse> {\n    const vpcId = vpc.VpcId!;\n\n    debug(`Describing VPC ${vpcId}`);\n\n    const filters = { Filters: [{ Name: 'vpc-id', Values: [vpcId] }] };\n\n    const subnetsResponse = await ec2.describeSubnets(filters);\n    const listedSubnets = subnetsResponse.Subnets || [];\n\n    const routeTablesResponse = await ec2.describeRouteTables(filters);\n    const routeTables = new RouteTables(routeTablesResponse.RouteTables || []);\n\n    // Now comes our job to separate these subnets out into AZs and subnet groups (Public, Private, Isolated)\n    // We have the following attributes to go on:\n    // - Type tag, we tag subnets with their type. In absence of this tag, we\n    //   determine the subnet must be Public if either:\n    //   a) it has the property MapPublicIpOnLaunch\n    //   b) it has a route to an Internet Gateway\n    //   If both of the above is false but the subnet has a route to a NAT Gateway\n    //   and the destination CIDR block is \"0.0.0.0/0\", we assume it to be a Private subnet.\n    //   Anything else is considered Isolated.\n    // - Name tag, we tag subnets with their subnet group name. In absence of this tag,\n    //   we use the type as the name.\n\n    const azs = Array.from(new Set<string>(listedSubnets.map((s) => s.AvailabilityZone!)));\n    azs.sort();\n\n    const subnets: Subnet[] = listedSubnets.map((subnet) => {\n      let type = getTag('aws-cdk:subnet-type', subnet.Tags);\n      if (type === undefined && subnet.MapPublicIpOnLaunch) {\n        type = SubnetType.Public;\n      }\n      if (type === undefined && routeTables.hasRouteToIgw(subnet.SubnetId)) {\n        type = SubnetType.Public;\n      }\n      if (type === undefined && routeTables.hasRouteToNatGateway(subnet.SubnetId)) {\n        type = SubnetType.Private;\n      }\n      if (type === undefined && routeTables.hasRouteToTransitGateway(subnet.SubnetId)) {\n        type = SubnetType.Private;\n      }\n      if (type === undefined) {\n        type = SubnetType.Isolated;\n      }\n\n      if (!isValidSubnetType(type)) {\n        // eslint-disable-next-line max-len\n        throw new ContextProviderError(\n          `Subnet ${subnet.SubnetArn} has invalid subnet type ${type} (must be ${SubnetType.Public}, ${SubnetType.Private} or ${SubnetType.Isolated})`,\n        );\n      }\n\n      if (args.subnetGroupNameTag && !getTag(args.subnetGroupNameTag, subnet.Tags)) {\n        throw new ContextProviderError(\n          `Invalid subnetGroupNameTag: Subnet ${subnet.SubnetArn} does not have an associated tag with Key='${args.subnetGroupNameTag}'`,\n        );\n      }\n\n      const name = getTag(args.subnetGroupNameTag || 'aws-cdk:subnet-name', subnet.Tags) || type;\n      const routeTableId = routeTables.routeTableIdForSubnetId(subnet.SubnetId);\n\n      if (!routeTableId) {\n        throw new ContextProviderError(\n          `Subnet ${subnet.SubnetArn} does not have an associated route table (and there is no \"main\" table)`,\n        );\n      }\n\n      return {\n        az: subnet.AvailabilityZone!,\n        cidr: subnet.CidrBlock!,\n        type,\n        name,\n        subnetId: subnet.SubnetId!,\n        routeTableId,\n      };\n    });\n\n    let grouped: SubnetGroups;\n    let assymetricSubnetGroups: VpcSubnetGroup[] | undefined;\n    if (args.returnAsymmetricSubnets) {\n      grouped = { azs: [], groups: [] };\n      assymetricSubnetGroups = groupAsymmetricSubnets(subnets);\n    } else {\n      grouped = groupSubnets(subnets);\n      assymetricSubnetGroups = undefined;\n    }\n\n    // Find attached+available VPN gateway for this VPC\n    const vpnGatewayResponse =\n      (args.returnVpnGateways ?? true)\n        ? await ec2.describeVpnGateways({\n          Filters: [\n            {\n              Name: 'attachment.vpc-id',\n              Values: [vpcId],\n            },\n            {\n              Name: 'attachment.state',\n              Values: ['attached'],\n            },\n            {\n              Name: 'state',\n              Values: ['available'],\n            },\n          ],\n        })\n        : undefined;\n    const vpnGatewayId =\n      vpnGatewayResponse?.VpnGateways?.length === 1 ? vpnGatewayResponse.VpnGateways[0].VpnGatewayId : undefined;\n\n    return {\n      vpcId,\n      vpcCidrBlock: vpc.CidrBlock!,\n      ownerAccountId: vpc.OwnerId,\n      availabilityZones: grouped.azs,\n      isolatedSubnetIds: collapse(\n        flatMap(findGroups(SubnetType.Isolated, grouped), (group) => group.subnets.map((s) => s.subnetId)),\n      ),\n      isolatedSubnetNames: collapse(\n        flatMap(findGroups(SubnetType.Isolated, grouped), (group) => (group.name ? [group.name] : [])),\n      ),\n      isolatedSubnetRouteTableIds: collapse(\n        flatMap(findGroups(SubnetType.Isolated, grouped), (group) => group.subnets.map((s) => s.routeTableId)),\n      ),\n      privateSubnetIds: collapse(\n        flatMap(findGroups(SubnetType.Private, grouped), (group) => group.subnets.map((s) => s.subnetId)),\n      ),\n      privateSubnetNames: collapse(\n        flatMap(findGroups(SubnetType.Private, grouped), (group) => (group.name ? [group.name] : [])),\n      ),\n      privateSubnetRouteTableIds: collapse(\n        flatMap(findGroups(SubnetType.Private, grouped), (group) => group.subnets.map((s) => s.routeTableId)),\n      ),\n      publicSubnetIds: collapse(\n        flatMap(findGroups(SubnetType.Public, grouped), (group) => group.subnets.map((s) => s.subnetId)),\n      ),\n      publicSubnetNames: collapse(\n        flatMap(findGroups(SubnetType.Public, grouped), (group) => (group.name ? [group.name] : [])),\n      ),\n      publicSubnetRouteTableIds: collapse(\n        flatMap(findGroups(SubnetType.Public, grouped), (group) => group.subnets.map((s) => s.routeTableId)),\n      ),\n      vpnGatewayId,\n      subnetGroups: assymetricSubnetGroups,\n    };\n  }\n}\n\nclass RouteTables {\n  public readonly mainRouteTable?: RouteTable;\n\n  constructor(private readonly tables: RouteTable[]) {\n    this.mainRouteTable = this.tables.find(\n      (table) => !!table.Associations && table.Associations.some((assoc) => !!assoc.Main),\n    );\n  }\n\n  public routeTableIdForSubnetId(subnetId: string | undefined): string | undefined {\n    const table = this.tableForSubnet(subnetId);\n    return (table && table.RouteTableId) || (this.mainRouteTable && this.mainRouteTable.RouteTableId);\n  }\n\n  /**\n   * Whether the given subnet has a route to a NAT Gateway\n   */\n  public hasRouteToNatGateway(subnetId: string | undefined): boolean {\n    const table = this.tableForSubnet(subnetId) || this.mainRouteTable;\n\n    return (\n      !!table &&\n      !!table.Routes &&\n      table.Routes.some((route) => !!route.NatGatewayId && route.DestinationCidrBlock === '0.0.0.0/0')\n    );\n  }\n\n  /**\n   * Whether the given subnet has a route to a Transit Gateway\n   */\n  public hasRouteToTransitGateway(subnetId: string | undefined): boolean {\n    const table = this.tableForSubnet(subnetId) || this.mainRouteTable;\n\n    return (\n      !!table &&\n      !!table.Routes &&\n      table.Routes.some((route) => !!route.TransitGatewayId && route.DestinationCidrBlock === '0.0.0.0/0')\n    );\n  }\n\n  /**\n   * Whether the given subnet has a route to an IGW\n   */\n  public hasRouteToIgw(subnetId: string | undefined): boolean {\n    const table = this.tableForSubnet(subnetId) || this.mainRouteTable;\n\n    return (\n      !!table && !!table.Routes && table.Routes.some((route) => !!route.GatewayId && route.GatewayId.startsWith('igw-'))\n    );\n  }\n\n  public tableForSubnet(subnetId: string | undefined) {\n    return this.tables.find(\n      (table) => !!table.Associations && table.Associations.some((assoc) => assoc.SubnetId === subnetId),\n    );\n  }\n}\n\n/**\n * Return the value of a tag from a set of tags\n */\nfunction getTag(name: string, tags?: Tag[]): string | undefined {\n  for (const tag of tags || []) {\n    if (tag.Key === name) {\n      return tag.Value;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Group subnets of the same type together, and order by AZ\n */\nfunction groupSubnets(subnets: Subnet[]): SubnetGroups {\n  const grouping: { [key: string]: Subnet[] } = {};\n  for (const subnet of subnets) {\n    const key = [subnet.type, subnet.name].toString();\n    if (!(key in grouping)) {\n      grouping[key] = [];\n    }\n    grouping[key].push(subnet);\n  }\n\n  const groups = Object.values(grouping).map((sns) => {\n    sns.sort((a: Subnet, b: Subnet) => a.az.localeCompare(b.az));\n    return {\n      type: sns[0].type,\n      name: sns[0].name,\n      subnets: sns,\n    };\n  });\n\n  const azs = groups[0].subnets.map((s) => s.az);\n\n  for (const group of groups) {\n    const groupAZs = group.subnets.map((s) => s.az);\n    if (!arraysEqual(groupAZs, azs)) {\n      throw new ContextProviderError(`Not all subnets in VPC have the same AZs: ${groupAZs} vs ${azs}`);\n    }\n  }\n\n  return { azs, groups };\n}\n\nfunction groupAsymmetricSubnets(subnets: Subnet[]): VpcSubnetGroup[] {\n  const grouping: { [key: string]: Subnet[] } = {};\n  for (const subnet of subnets) {\n    const key = [subnet.type, subnet.name].toString();\n    if (!(key in grouping)) {\n      grouping[key] = [];\n    }\n    grouping[key].push(subnet);\n  }\n\n  return Object.values(grouping).map((subnetArray) => {\n    subnetArray.sort((subnet1: Subnet, subnet2: Subnet) => subnet1.az.localeCompare(subnet2.az));\n\n    return {\n      name: subnetArray[0].name,\n      type: subnetTypeToVpcSubnetType(subnetArray[0].type),\n      subnets: subnetArray.map((subnet) => ({\n        subnetId: subnet.subnetId,\n        cidr: subnet.cidr,\n        availabilityZone: subnet.az,\n        routeTableId: subnet.routeTableId,\n      })),\n    };\n  });\n}\n\nfunction subnetTypeToVpcSubnetType(type: SubnetType): VpcSubnetGroupType {\n  switch (type) {\n    case SubnetType.Isolated:\n      return VpcSubnetGroupType.ISOLATED;\n    case SubnetType.Private:\n      return VpcSubnetGroupType.PRIVATE;\n    case SubnetType.Public:\n      return VpcSubnetGroupType.PUBLIC;\n  }\n}\n\nenum SubnetType {\n  Public = 'Public',\n  Private = 'Private',\n  Isolated = 'Isolated',\n}\n\nfunction isValidSubnetType(val: string): val is SubnetType {\n  return val === SubnetType.Public || val === SubnetType.Private || val === SubnetType.Isolated;\n}\n\ninterface Subnet {\n  az: string;\n  cidr: string;\n  type: SubnetType;\n  name: string;\n  routeTableId: string;\n  subnetId: string;\n}\n\ninterface SubnetGroup {\n  type: SubnetType;\n  name: string;\n  subnets: Subnet[];\n}\n\ninterface SubnetGroups {\n  azs: string[];\n  groups: SubnetGroup[];\n}\n\nfunction arraysEqual(as: string[], bs: string[]): boolean {\n  if (as.length !== bs.length) {\n    return false;\n  }\n\n  for (let i = 0; i < as.length; i++) {\n    if (as[i] !== bs[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction findGroups(type: SubnetType, groups: SubnetGroups): SubnetGroup[] {\n  return groups.groups.filter((g) => g.type === type);\n}\n\nfunction flatMap<T, U>(xs: T[], fn: (x: T) => U[]): U[] {\n  const ret = new Array<U>();\n  for (const x of xs) {\n    ret.push(...fn(x));\n  }\n  return ret;\n}\n\nfunction collapse<T>(xs: T[]): T[] | undefined {\n  if (xs.length > 0) {\n    return xs;\n  }\n  return undefined;\n}\n"]}

package/lib/diff.d.ts

@@ -0,0 +1,28 @@
+import { type DescribeChangeSetOutput, type FormatStream } from '@aws-cdk/cloudformation-diff';
+import * as cxapi from '@aws-cdk/cx-api';
+import { type NestedStackTemplates } from './api/deployments';
+/**
+ * Pretty-prints the differences between two template states to the console.
+ *
+ * @param oldTemplate the old/current state of the stack.
+ * @param newTemplate the new/target state of the stack.
+ * @param strict      do not filter out AWS::CDK::Metadata or Rules
+ * @param context     lines of context to use in arbitrary JSON diff
+ * @param quiet       silences \'There were no differences\' messages
+ *
+ * @returns the number of stacks in this stack tree that have differences, including the top-level root stack
+ */
+export declare function printStackDiff(oldTemplate: any, newTemplate: cxapi.CloudFormationStackArtifact, strict: boolean, context: number, quiet: boolean, stackName?: string, changeSet?: DescribeChangeSetOutput, isImport?: boolean, stream?: FormatStream, nestedStackTemplates?: {
+    [nestedStackLogicalId: string]: NestedStackTemplates;
+}): number;
+export declare enum RequireApproval {
+    Never = "never",
+    AnyChange = "any-change",
+    Broadening = "broadening"
+}
+/**
+ * Print the security changes of this diff, if the change is impactful enough according to the approval level
+ *
+ * Returns true if the changes are prompt-worthy, false otherwise.
+ */
+export declare function printSecurityDiff(oldTemplate: any, newTemplate: cxapi.CloudFormationStackArtifact, requireApproval: RequireApproval, _quiet?: boolean, stackName?: string, changeSet?: DescribeChangeSetOutput, stream?: FormatStream): boolean;

package/lib/diff.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireApproval = void 0;
+exports.printStackDiff = printStackDiff;
+exports.printSecurityDiff = printSecurityDiff;
+const util_1 = require("util");
+const cxschema = require("@aws-cdk/cloud-assembly-schema");
+const cloudformation_diff_1 = require("@aws-cdk/cloudformation-diff");
+const chalk = require("chalk");
+const logging_1 = require("./logging");
+const error_1 = require("./toolkit/error");
+/**
+ * Pretty-prints the differences between two template states to the console.
+ *
+ * @param oldTemplate the old/current state of the stack.
+ * @param newTemplate the new/target state of the stack.
+ * @param strict      do not filter out AWS::CDK::Metadata or Rules
+ * @param context     lines of context to use in arbitrary JSON diff
+ * @param quiet       silences \'There were no differences\' messages
+ *
+ * @returns the number of stacks in this stack tree that have differences, including the top-level root stack
+ */
+function printStackDiff(oldTemplate, newTemplate, strict, context, quiet, stackName, changeSet, isImport, stream = process.stderr, nestedStackTemplates) {
+    var _a;
+    let diff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, newTemplate.template, changeSet, isImport);
+    // must output the stack name if there are differences, even if quiet
+    if (stackName && (!quiet || !diff.isEmpty)) {
+        stream.write((0, util_1.format)('Stack %s\n', chalk.bold(stackName)));
+    }
+    if (!quiet && isImport) {
+        stream.write('Parameters and rules created during migration do not affect resource configuration.\n');
+    }
+    // detect and filter out mangled characters from the diff
+    let filteredChangesCount = 0;
+    if (diff.differenceCount && !strict) {
+        const mangledNewTemplate = JSON.parse((0, cloudformation_diff_1.mangleLikeCloudFormation)(JSON.stringify(newTemplate.template)));
+        const mangledDiff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, mangledNewTemplate, changeSet);
+        filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);
+        if (filteredChangesCount > 0) {
+            diff = mangledDiff;
+        }
+    }
+    // filter out 'AWS::CDK::Metadata' resources from the template
+    // filter out 'CheckBootstrapVersion' rules from the template
+    if (!strict) {
+        obscureDiff(diff);
+    }
+    let stackDiffCount = 0;
+    if (!diff.isEmpty) {
+        stackDiffCount++;
+        (0, cloudformation_diff_1.formatDifferences)(stream, diff, {
+            ...logicalIdMapFromTemplate(oldTemplate),
+            ...buildLogicalToPathMap(newTemplate),
+        }, context);
+    }
+    else if (!quiet) {
+        (0, logging_1.info)(chalk.green('There were no differences'));
+    }
+    if (filteredChangesCount > 0) {
+        (0, logging_1.info)(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.`));
+    }
+    for (const nestedStackLogicalId of Object.keys(nestedStackTemplates !== null && nestedStackTemplates !== void 0 ? nestedStackTemplates : {})) {
+        if (!nestedStackTemplates) {
+            break;
+        }
+        const nestedStack = nestedStackTemplates[nestedStackLogicalId];
+        newTemplate._template = nestedStack.generatedTemplate;
+        stackDiffCount += printStackDiff(nestedStack.deployedTemplate, newTemplate, strict, context, quiet, (_a = nestedStack.physicalName) !== null && _a !== void 0 ? _a : nestedStackLogicalId, undefined, isImport, stream, nestedStack.nestedStackTemplates);
+    }
+    return stackDiffCount;
+}
+var RequireApproval;
+(function (RequireApproval) {
+    RequireApproval["Never"] = "never";
+    RequireApproval["AnyChange"] = "any-change";
+    RequireApproval["Broadening"] = "broadening";
+})(RequireApproval || (exports.RequireApproval = RequireApproval = {}));
+/**
+ * Print the security changes of this diff, if the change is impactful enough according to the approval level
+ *
+ * Returns true if the changes are prompt-worthy, false otherwise.
+ */
+function printSecurityDiff(oldTemplate, newTemplate, requireApproval, _quiet, stackName, changeSet, stream = process.stderr) {
+    const diff = (0, cloudformation_diff_1.fullDiff)(oldTemplate, newTemplate.template, changeSet);
+    if (diffRequiresApproval(diff, requireApproval)) {
+        stream.write((0, util_1.format)('Stack %s\n', chalk.bold(stackName)));
+        // eslint-disable-next-line max-len
+        (0, logging_1.warning)(`This deployment will make potentially sensitive changes according to your current security approval level (--require-approval ${requireApproval}).`);
+        (0, logging_1.warning)('Please confirm you intend to make the following modifications:\n');
+        (0, cloudformation_diff_1.formatSecurityChanges)(process.stdout, diff, buildLogicalToPathMap(newTemplate));
+        return true;
+    }
+    return false;
+}
+/**
+ * Return whether the diff has security-impacting changes that need confirmation
+ *
+ * TODO: Filter the security impact determination based off of an enum that allows
+ * us to pick minimum "severities" to alert on.
+ */
+function diffRequiresApproval(diff, requireApproval) {
+    switch (requireApproval) {
+        case RequireApproval.Never: return false;
+        case RequireApproval.AnyChange: return diff.permissionsAnyChanges;
+        case RequireApproval.Broadening: return diff.permissionsBroadened;
+        default: throw new error_1.ToolkitError(`Unrecognized approval level: ${requireApproval}`);
+    }
+}
+function buildLogicalToPathMap(stack) {
+    const map = {};
+    for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {
+        map[md.data] = md.path;
+    }
+    return map;
+}
+function logicalIdMapFromTemplate(template) {
+    var _a, _b;
+    const ret = {};
+    for (const [logicalId, resource] of Object.entries((_a = template.Resources) !== null && _a !== void 0 ? _a : {})) {
+        const path = (_b = resource === null || resource === void 0 ? void 0 : resource.Metadata) === null || _b === void 0 ? void 0 : _b['aws:cdk:path'];
+        if (path) {
+            ret[logicalId] = path;
+        }
+    }
+    return ret;
+}
+/**
+ * Remove any template elements that we don't want to show users.
+ * This is currently:
+ * - AWS::CDK::Metadata resource
+ * - CheckBootstrapVersion Rule
+ */
+function obscureDiff(diff) {
+    if (diff.unknown) {
+        // see https://github.com/aws/aws-cdk/issues/17942
+        diff.unknown = diff.unknown.filter(change => {
+            var _a, _b;
+            if (!change) {
+                return true;
+            }
+            if ((_a = change.newValue) === null || _a === void 0 ? void 0 : _a.CheckBootstrapVersion) {
+                return false;
+            }
+            if ((_b = change.oldValue) === null || _b === void 0 ? void 0 : _b.CheckBootstrapVersion) {
+                return false;
+            }
+            return true;
+        });
+    }
+    if (diff.resources) {
+        diff.resources = diff.resources.filter(change => {
+            if (!change) {
+                return true;
+            }
+            if (change.newResourceType === 'AWS::CDK::Metadata') {
+                return false;
+            }
+            if (change.oldResourceType === 'AWS::CDK::Metadata') {
+                return false;
+            }
+            return true;
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff.js","sourceRoot":"","sources":["diff.ts"],"names":[],"mappings":"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","sourcesContent":["import { format } from 'util';\nimport * as cxschema from '@aws-cdk/cloud-assembly-schema';\nimport {\n  type DescribeChangeSetOutput,\n  type FormatStream,\n  type TemplateDiff,\n  formatDifferences,\n  formatSecurityChanges,\n  fullDiff,\n  mangleLikeCloudFormation,\n} from '@aws-cdk/cloudformation-diff';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport * as chalk from 'chalk';\nimport { type NestedStackTemplates } from './api/deployments';\nimport { info, warning } from './logging';\nimport { ToolkitError } from './toolkit/error';\n\n/**\n * Pretty-prints the differences between two template states to the console.\n *\n * @param oldTemplate the old/current state of the stack.\n * @param newTemplate the new/target state of the stack.\n * @param strict      do not filter out AWS::CDK::Metadata or Rules\n * @param context     lines of context to use in arbitrary JSON diff\n * @param quiet       silences \\'There were no differences\\' messages\n *\n * @returns the number of stacks in this stack tree that have differences, including the top-level root stack\n */\nexport function printStackDiff(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  strict: boolean,\n  context: number,\n  quiet: boolean,\n  stackName?: string,\n  changeSet?: DescribeChangeSetOutput,\n  isImport?: boolean,\n  stream: FormatStream = process.stderr,\n  nestedStackTemplates?: { [nestedStackLogicalId: string]: NestedStackTemplates }): number {\n  let diff = fullDiff(oldTemplate, newTemplate.template, changeSet, isImport);\n\n  // must output the stack name if there are differences, even if quiet\n  if (stackName && (!quiet || !diff.isEmpty)) {\n    stream.write(format('Stack %s\\n', chalk.bold(stackName)));\n  }\n\n  if (!quiet && isImport) {\n    stream.write('Parameters and rules created during migration do not affect resource configuration.\\n');\n  }\n\n  // detect and filter out mangled characters from the diff\n  let filteredChangesCount = 0;\n  if (diff.differenceCount && !strict) {\n    const mangledNewTemplate = JSON.parse(mangleLikeCloudFormation(JSON.stringify(newTemplate.template)));\n    const mangledDiff = fullDiff(oldTemplate, mangledNewTemplate, changeSet);\n    filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);\n    if (filteredChangesCount > 0) {\n      diff = mangledDiff;\n    }\n  }\n\n  // filter out 'AWS::CDK::Metadata' resources from the template\n  // filter out 'CheckBootstrapVersion' rules from the template\n  if (!strict) {\n    obscureDiff(diff);\n  }\n\n  let stackDiffCount = 0;\n  if (!diff.isEmpty) {\n    stackDiffCount++;\n    formatDifferences(stream, diff, {\n      ...logicalIdMapFromTemplate(oldTemplate),\n      ...buildLogicalToPathMap(newTemplate),\n    }, context);\n  } else if (!quiet) {\n    info(chalk.green('There were no differences'));\n  }\n  if (filteredChangesCount > 0) {\n    info(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.`));\n  }\n\n  for (const nestedStackLogicalId of Object.keys(nestedStackTemplates ?? {})) {\n    if (!nestedStackTemplates) {\n      break;\n    }\n    const nestedStack = nestedStackTemplates[nestedStackLogicalId];\n\n    (newTemplate as any)._template = nestedStack.generatedTemplate;\n    stackDiffCount += printStackDiff(\n      nestedStack.deployedTemplate,\n      newTemplate,\n      strict,\n      context,\n      quiet,\n      nestedStack.physicalName ?? nestedStackLogicalId,\n      undefined,\n      isImport,\n      stream,\n      nestedStack.nestedStackTemplates,\n    );\n  }\n\n  return stackDiffCount;\n}\n\nexport enum RequireApproval {\n  Never = 'never',\n\n  AnyChange = 'any-change',\n\n  Broadening = 'broadening',\n}\n\n/**\n * Print the security changes of this diff, if the change is impactful enough according to the approval level\n *\n * Returns true if the changes are prompt-worthy, false otherwise.\n */\nexport function printSecurityDiff(\n  oldTemplate: any,\n  newTemplate: cxapi.CloudFormationStackArtifact,\n  requireApproval: RequireApproval,\n  _quiet?: boolean,\n  stackName?: string,\n  changeSet?: DescribeChangeSetOutput,\n  stream: FormatStream = process.stderr,\n): boolean {\n  const diff = fullDiff(oldTemplate, newTemplate.template, changeSet);\n\n  if (diffRequiresApproval(diff, requireApproval)) {\n    stream.write(format('Stack %s\\n', chalk.bold(stackName)));\n\n    // eslint-disable-next-line max-len\n    warning(`This deployment will make potentially sensitive changes according to your current security approval level (--require-approval ${requireApproval}).`);\n    warning('Please confirm you intend to make the following modifications:\\n');\n\n    formatSecurityChanges(process.stdout, diff, buildLogicalToPathMap(newTemplate));\n    return true;\n  }\n  return false;\n}\n\n/**\n * Return whether the diff has security-impacting changes that need confirmation\n *\n * TODO: Filter the security impact determination based off of an enum that allows\n * us to pick minimum \"severities\" to alert on.\n */\nfunction diffRequiresApproval(diff: TemplateDiff, requireApproval: RequireApproval) {\n  switch (requireApproval) {\n    case RequireApproval.Never: return false;\n    case RequireApproval.AnyChange: return diff.permissionsAnyChanges;\n    case RequireApproval.Broadening: return diff.permissionsBroadened;\n    default: throw new ToolkitError(`Unrecognized approval level: ${requireApproval}`);\n  }\n}\n\nfunction buildLogicalToPathMap(stack: cxapi.CloudFormationStackArtifact) {\n  const map: { [id: string]: string } = {};\n  for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {\n    map[md.data as string] = md.path;\n  }\n  return map;\n}\n\nfunction logicalIdMapFromTemplate(template: any) {\n  const ret: Record<string, string> = {};\n\n  for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {\n    const path = (resource as any)?.Metadata?.['aws:cdk:path'];\n    if (path) {\n      ret[logicalId] = path;\n    }\n  }\n  return ret;\n}\n\n/**\n * Remove any template elements that we don't want to show users.\n * This is currently:\n * - AWS::CDK::Metadata resource\n * - CheckBootstrapVersion Rule\n */\nfunction obscureDiff(diff: TemplateDiff) {\n  if (diff.unknown) {\n    // see https://github.com/aws/aws-cdk/issues/17942\n    diff.unknown = diff.unknown.filter(change => {\n      if (!change) { return true; }\n      if (change.newValue?.CheckBootstrapVersion) { return false; }\n      if (change.oldValue?.CheckBootstrapVersion) { return false; }\n      return true;\n    });\n  }\n\n  if (diff.resources) {\n    diff.resources = diff.resources.filter(change => {\n      if (!change) { return true; }\n      if (change.newResourceType === 'AWS::CDK::Metadata') { return false; }\n      if (change.oldResourceType === 'AWS::CDK::Metadata') { return false; }\n      return true;\n    });\n  }\n}\n"]}