@l-v-yonsama/multi-platform-database-drivers 1.2.0 → 1.3.0

package/built/src/utils/cfn/architectureTopology.d.ts

@@ -0,0 +1,128 @@
+import { DiagramFile, RefValue, TemplateResource } from '../../types';
+type SubnetConnectivity = 'public' | 'private' | 'isolated';
+type TopologySubnetResource = {
+    fileIndex: number;
+    logicalId: string;
+    exportedName?: string;
+    detail: TemplateResource;
+};
+type TopologyVpcResource = TopologySubnetResource & {
+    placement: string;
+    candidateSubnets: TopologySubnet[];
+    multiAz?: boolean;
+};
+type TopologyDefaultRoute = {
+    kind: 'internet-gateway' | 'nat-gateway' | 'egress-only-internet-gateway';
+    fileIndex: number;
+    logicalId?: string;
+};
+type TopologySubnet = {
+    fileIndex: number;
+    logicalId: string;
+    exportedName?: string;
+    connectivity: SubnetConnectivity;
+    cidrBlock: string;
+    resources: TopologySubnetResource[];
+    defaultRoute?: TopologyDefaultRoute;
+};
+type TopologyAvailabilityZone = {
+    id: string;
+    name: string;
+    subnets: TopologySubnet[];
+};
+type TopologyTarget = {
+    sourceFileIndex: number;
+    logicalId: RefValue;
+};
+type TopologyTargetGroup = {
+    fileIndex: number;
+    logicalId: string;
+    protocol?: string;
+    port?: string;
+    targetType?: string;
+    targets: TopologyTarget[];
+};
+type TopologyLoadBalancer = {
+    fileIndex: number;
+    logicalId: string;
+    internetFacing: boolean;
+    subnets: TopologySubnet[];
+    targetGroups: TopologyTargetGroup[];
+    listeners: TopologyListener[];
+};
+type TopologyListenerRule = {
+    fileIndex: number;
+    logicalId: string;
+    conditions: string[];
+    priority?: string;
+    targetGroups: TopologyTargetGroup[];
+};
+type TopologyListener = {
+    fileIndex: number;
+    logicalId: string;
+    protocol?: string;
+    port?: string;
+    targetGroups: TopologyTargetGroup[];
+    rules: TopologyListenerRule[];
+};
+type TopologyIgw = {
+    fileIndex: number;
+    logicalId: string;
+};
+type TopologyNatGateway = {
+    fileIndex: number;
+    logicalId: string;
+    subnet: TopologySubnet;
+};
+type TopologyVpc = {
+    readonly fileIndex: number;
+    readonly logicalId: string;
+    exportedName?: string;
+    readonly cidrBlock: string;
+    readonly availabilityZones: TopologyAvailabilityZone[];
+    readonly resources: TopologyVpcResource[];
+    readonly loadBalancers: TopologyLoadBalancer[];
+    readonly natGateways: TopologyNatGateway[];
+    igw?: TopologyIgw;
+};
+type TopologyStandaloneResource = {
+    fileIndex: number;
+    logicalId: string;
+    detail: TemplateResource;
+};
+export declare class CfnArchitectureDiagramStructure {
+    private readonly diagramFiles;
+    readonly vpcs: TopologyVpc[];
+    readonly standaloneResources: TopologyStandaloneResource[];
+    constructor(diagramFiles: DiagramFile[]);
+    getResourceFrom(reference: TopologyTarget): {
+        vpc: TopologyVpc;
+        subnet?: TopologySubnet;
+        resource: TopologySubnetResource | TopologyVpcResource;
+    } | undefined;
+    private collectVpcs;
+    private collectSubnets;
+    private getOrCreateAvailabilityZone;
+    private classifySubnetConnectivity;
+    private attachSubnetAndVpcResources;
+    private attachEc2Instance;
+    private attachNatGateway;
+    private attachDatabase;
+    private attachEcsService;
+    private attachInternetGateway;
+    private collectLoadBalancers;
+    private listenersForLoadBalancer;
+    private targetGroupsFromActions;
+    private targetGroupsForLoadBalancer;
+    private toTopologyTargetGroup;
+    private topologyResource;
+    private addStandalone;
+    private normalizeRef;
+    private findTemplateResource;
+    private getVpc;
+    private getSubnet;
+    private resourceMatches;
+    private vpcForSubnet;
+    private allSubnets;
+}
+export {};

package/built/src/utils/cfn/architectureTopology.js

@@ -0,0 +1,523 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CfnArchitectureDiagramStructure = void 0;
+const intrinsics_1 = require("./intrinsics");
+const naming_1 = require("./naming");
+const sortSubnets = (a, b) => {
+    const priority = {
+        public: 0,
+        private: 1,
+        isolated: 2,
+    };
+    return priority[a.connectivity] - priority[b.connectivity] ||
+        a.cidrBlock.localeCompare(b.cidrBlock);
+};
+const uniqueByIdentity = (values) => Array.from(new Map(values.map((value) => [
+    `${value.fileIndex}:${value.logicalId}`,
+    value,
+])).values());
+const displayProperty = (value) => {
+    const resolved = (0, intrinsics_1.resolveCfnString)(value);
+    if (resolved !== undefined)
+        return resolved;
+    if (value === undefined || value === null)
+        return undefined;
+    const serialized = JSON.stringify(value);
+    return serialized.length > 80 ? `${serialized.slice(0, 77)}...` : serialized;
+};
+const listenerRuleConditions = (conditions) => {
+    if (!Array.isArray(conditions))
+        return [];
+    return conditions.flatMap((condition) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const field = (_a = displayProperty(condition === null || condition === void 0 ? void 0 : condition.Field)) !== null && _a !== void 0 ? _a : 'condition';
+        const values = (_k = (_h = (_f = (_d = (_b = condition === null || condition === void 0 ? void 0 : condition.Values) !== null && _b !== void 0 ? _b : (_c = condition === null || condition === void 0 ? void 0 : condition.PathPatternConfig) === null || _c === void 0 ? void 0 : _c.Values) !== null && _d !== void 0 ? _d : (_e = condition === null || condition === void 0 ? void 0 : condition.HostHeaderConfig) === null || _e === void 0 ? void 0 : _e.Values) !== null && _f !== void 0 ? _f : (_g = condition === null || condition === void 0 ? void 0 : condition.HttpHeaderConfig) === null || _g === void 0 ? void 0 : _g.Values) !== null && _h !== void 0 ? _h : (_j = condition === null || condition === void 0 ? void 0 : condition.QueryStringConfig) === null || _j === void 0 ? void 0 : _j.Values) !== null && _k !== void 0 ? _k : (_l = condition === null || condition === void 0 ? void 0 : condition.SourceIpConfig) === null || _l === void 0 ? void 0 : _l.Values;
+        if (!Array.isArray(values) || values.length === 0)
+            return [field];
+        return [`${field}: ${values.map((value) => { var _a; return (_a = displayProperty(value)) !== null && _a !== void 0 ? _a : '?'; }).join(', ')}`];
+    });
+};
+const availabilityZoneName = (value, file) => {
+    var _a, _b, _c, _d, _e;
+    if (typeof value === 'string')
+        return value;
+    const resolutionContext = {
+        parameters: file.cfnTemplate.Parameters,
+        parameterValues: file.parameterValues,
+        pseudoParameters: Object.assign({ 'AWS::StackName': file.groupName }, file.pseudoParameterValues),
+    };
+    const resolved = (0, intrinsics_1.resolveCfnString)(value, resolutionContext);
+    if (resolved)
+        return resolved;
+    const select = (_a = value === null || value === void 0 ? void 0 : value['Fn::Select']) !== null && _a !== void 0 ? _a : value === null || value === void 0 ? void 0 : value['!Select'];
+    if (Array.isArray(select) && select.length >= 2) {
+        const index = (0, intrinsics_1.resolveCfnString)(select[0], resolutionContext);
+        const getAzs = (_c = (_b = select[1]) === null || _b === void 0 ? void 0 : _b['Fn::GetAZs']) !== null && _c !== void 0 ? _c : (_d = select[1]) === null || _d === void 0 ? void 0 : _d['!GetAZs'];
+        if (index !== undefined && getAzs !== undefined) {
+            const selectedRegion = (0, intrinsics_1.resolveCfnString)(getAzs, resolutionContext);
+            const region = selectedRegion || ((_e = file.pseudoParameterValues) === null || _e === void 0 ? void 0 : _e['AWS::Region']);
+            return region
+                ? `${region} AZ index ${index}`
+                : `Availability Zone index ${index}`;
+        }
+    }
+    return value ? JSON.stringify(value) : 'unspecified';
+};
+class CfnArchitectureDiagramStructure {
+    constructor(diagramFiles) {
+        this.diagramFiles = diagramFiles;
+        this.vpcs = [];
+        this.standaloneResources = [];
+        diagramFiles.forEach((file) => this.collectVpcs(file));
+        diagramFiles.forEach((file) => this.collectSubnets(file));
+        diagramFiles.forEach((file) => this.classifySubnetConnectivity(file));
+        diagramFiles.forEach((file) => this.attachSubnetAndVpcResources(file));
+        diagramFiles.forEach((file) => this.attachInternetGateway(file));
+        diagramFiles.forEach((file) => this.collectLoadBalancers(file));
+    }
+    getResourceFrom(reference) {
+        const normalized = this.normalizeRef(reference.logicalId.rawValue, reference.sourceFileIndex);
+        for (const vpc of this.vpcs) {
+            for (const resource of vpc.resources) {
+                if (this.resourceMatches(resource, normalized, reference.sourceFileIndex)) {
+                    return { vpc, resource };
+                }
+            }
+            for (const az of vpc.availabilityZones) {
+                for (const subnet of az.subnets) {
+                    const resource = subnet.resources.find((candidate) => this.resourceMatches(candidate, normalized, reference.sourceFileIndex));
+                    if (resource)
+                        return { vpc, subnet, resource };
+                }
+            }
+        }
+        return undefined;
+    }
+    collectVpcs(file) {
+        Object.entries(file.cfnTemplate.Resources)
+            .filter(([, resource]) => resource.Type === 'AWS::EC2::VPC')
+            .forEach(([logicalId, resource]) => {
+            this.vpcs.push({
+                fileIndex: file.fileIndex,
+                logicalId,
+                cidrBlock: (0, naming_1.getCidrBlock)(resource.Properties),
+                availabilityZones: [],
+                resources: [],
+                loadBalancers: [],
+                natGateways: [],
+            });
+        });
+        file.outputs.forEach((output) => {
+            const vpc = this.vpcs.find((candidate) => candidate.fileIndex === file.fileIndex &&
+                candidate.logicalId === output.value.logicalId);
+            if (vpc && output.export.rawName)
+                vpc.exportedName = output.export.rawName;
+        });
+    }
+    collectSubnets(file) {
+        Object.entries(file.cfnTemplate.Resources)
+            .filter(([, resource]) => resource.Type === 'AWS::EC2::Subnet')
+            .forEach(([logicalId, resource]) => {
+            var _a;
+            const vpc = this.getVpc(this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.VpcId, file.fileIndex), file.fileIndex);
+            if (!vpc) {
+                console.warn(`VPC not found for subnet ${file.fileName}:${logicalId}.`);
+                return;
+            }
+            const az = this.getOrCreateAvailabilityZone(vpc, resource, file);
+            az.subnets.push({
+                fileIndex: file.fileIndex,
+                logicalId,
+                connectivity: 'isolated',
+                cidrBlock: (0, naming_1.getCidrBlock)(resource.Properties),
+                resources: [],
+            });
+        });
+        file.outputs.forEach((output) => {
+            const subnet = this.allSubnets().find((candidate) => candidate.fileIndex === file.fileIndex &&
+                candidate.logicalId === output.value.logicalId);
+            if (subnet && output.export.rawName)
+                subnet.exportedName = output.export.rawName;
+        });
+    }
+    getOrCreateAvailabilityZone(vpc, subnetResource, file) {
+        var _a;
+        const availabilityZone = (_a = subnetResource.Properties) === null || _a === void 0 ? void 0 : _a.AvailabilityZone;
+        const azName = availabilityZoneName(availabilityZone, file);
+        const azId = (0, naming_1.sanitizeLogicalId)(azName);
+        let az = vpc.availabilityZones.find((candidate) => candidate.id === azId);
+        if (!az) {
+            az = { id: azId, name: azName, subnets: [] };
+            vpc.availabilityZones.push(az);
+        }
+        return az;
+    }
+    classifySubnetConnectivity(file) {
+        const resources = file.cfnTemplate.Resources;
+        Object.values(resources)
+            .filter((resource) => resource.Type === 'AWS::EC2::SubnetRouteTableAssociation')
+            .forEach((association) => {
+            var _a, _b, _c, _d, _e;
+            const subnet = this.getSubnet(this.normalizeRef((_a = association.Properties) === null || _a === void 0 ? void 0 : _a.SubnetId, file.fileIndex), file.fileIndex);
+            const routeTableRef = this.normalizeRef((_b = association.Properties) === null || _b === void 0 ? void 0 : _b.RouteTableId, file.fileIndex);
+            if (!subnet || routeTableRef.type === 'ImportValue')
+                return;
+            const routes = Object.values(resources).filter((resource) => {
+                var _a, _b, _c;
+                return resource.Type === 'AWS::EC2::Route' &&
+                    this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.RouteTableId, file.fileIndex).value === routeTableRef.value &&
+                    (((_b = resource.Properties) === null || _b === void 0 ? void 0 : _b.DestinationCidrBlock) === '0.0.0.0/0' ||
+                        ((_c = resource.Properties) === null || _c === void 0 ? void 0 : _c.DestinationIpv6CidrBlock) === '::/0');
+            });
+            const internetRoute = routes.find((route) => {
+                var _a;
+                const gatewayValue = (_a = route.Properties) === null || _a === void 0 ? void 0 : _a.GatewayId;
+                if (typeof gatewayValue === 'string')
+                    return gatewayValue.startsWith('igw-');
+                const gateway = this.findTemplateResource(this.normalizeRef(gatewayValue, file.fileIndex), file.fileIndex);
+                return (gateway === null || gateway === void 0 ? void 0 : gateway.detail.Type) === 'AWS::EC2::InternetGateway';
+            });
+            const natRoute = routes.find((route) => { var _a; return ((_a = route.Properties) === null || _a === void 0 ? void 0 : _a.NatGatewayId) !== undefined; });
+            const egressOnlyRoute = routes.find((route) => { var _a; return ((_a = route.Properties) === null || _a === void 0 ? void 0 : _a.EgressOnlyInternetGatewayId) !== undefined; });
+            if (internetRoute) {
+                subnet.connectivity = 'public';
+                const gatewayRef = this.normalizeRef((_c = internetRoute.Properties) === null || _c === void 0 ? void 0 : _c.GatewayId, file.fileIndex);
+                subnet.defaultRoute = {
+                    kind: 'internet-gateway',
+                    fileIndex: file.fileIndex,
+                    logicalId: gatewayRef.value || undefined,
+                };
+            }
+            else if (natRoute) {
+                subnet.connectivity = 'private';
+                const natRef = this.normalizeRef((_d = natRoute.Properties) === null || _d === void 0 ? void 0 : _d.NatGatewayId, file.fileIndex);
+                subnet.defaultRoute = {
+                    kind: 'nat-gateway',
+                    fileIndex: file.fileIndex,
+                    logicalId: natRef.value || undefined,
+                };
+            }
+            else if (egressOnlyRoute) {
+                subnet.connectivity = 'private';
+                const gatewayRef = this.normalizeRef((_e = egressOnlyRoute.Properties) === null || _e === void 0 ? void 0 : _e.EgressOnlyInternetGatewayId, file.fileIndex);
+                subnet.defaultRoute = {
+                    kind: 'egress-only-internet-gateway',
+                    fileIndex: file.fileIndex,
+                    logicalId: gatewayRef.value || undefined,
+                };
+            }
+            else {
+                subnet.connectivity = 'isolated';
+                subnet.defaultRoute = undefined;
+            }
+        });
+        this.vpcs.forEach((vpc) => vpc.availabilityZones.forEach((az) => az.subnets.sort(sortSubnets)));
+    }
+    attachSubnetAndVpcResources(file) {
+        Object.entries(file.cfnTemplate.Resources).forEach(([logicalId, resource]) => {
+            switch (resource.Type) {
+                case 'AWS::EC2::Instance':
+                    this.attachEc2Instance(file, logicalId, resource);
+                    break;
+                case 'AWS::EC2::NatGateway':
+                    this.attachNatGateway(file, logicalId, resource);
+                    break;
+                case 'AWS::RDS::DBInstance':
+                case 'AWS::RDS::DBCluster':
+                    this.attachDatabase(file, logicalId, resource);
+                    break;
+                case 'AWS::ECS::Service':
+                    this.attachEcsService(file, logicalId, resource);
+                    break;
+            }
+        });
+    }
+    attachEc2Instance(file, logicalId, resource) {
+        var _a, _b, _c, _d, _e;
+        const subnetValue = (_b = (_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.SubnetId) !== null && _b !== void 0 ? _b : (_e = (_d = (_c = resource.Properties) === null || _c === void 0 ? void 0 : _c.NetworkInterfaces) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.SubnetId;
+        const subnet = this.getSubnet(this.normalizeRef(subnetValue, file.fileIndex), file.fileIndex);
+        if (!subnet) {
+            this.addStandalone(file, logicalId, resource, 'EC2 Instance has no resolvable subnet');
+            return;
+        }
+        subnet.resources.push(this.topologyResource(file, logicalId, resource));
+    }
+    attachNatGateway(file, logicalId, resource) {
+        var _a;
+        const subnet = this.getSubnet(this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.SubnetId, file.fileIndex), file.fileIndex);
+        if (!subnet)
+            return;
+        const vpc = this.vpcForSubnet(subnet);
+        if (!vpc)
+            return;
+        const topologyResource = this.topologyResource(file, logicalId, resource);
+        subnet.resources.push(topologyResource);
+        vpc.natGateways.push({ fileIndex: file.fileIndex, logicalId, subnet });
+    }
+    attachDatabase(file, logicalId, resource) {
+        var _a, _b, _c;
+        const subnetGroupRef = this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.DBSubnetGroupName, file.fileIndex);
+        const subnetGroup = this.findTemplateResource(subnetGroupRef, file.fileIndex);
+        const subnetIds = (_b = subnetGroup === null || subnetGroup === void 0 ? void 0 : subnetGroup.detail.Properties) === null || _b === void 0 ? void 0 : _b.SubnetIds;
+        if (!subnetGroup || !Array.isArray(subnetIds)) {
+            this.addStandalone(file, logicalId, resource, 'database has no resolvable DB subnet group');
+            return;
+        }
+        const subnets = subnetIds
+            .map((value) => this.getSubnet(this.normalizeRef(value, subnetGroup.file.fileIndex), subnetGroup.file.fileIndex))
+            .filter((subnet) => Boolean(subnet));
+        const vpcs = uniqueByIdentity(subnets.flatMap((subnet) => {
+            const vpc = this.vpcForSubnet(subnet);
+            return vpc ? [vpc] : [];
+        }));
+        if (subnets.length === 0 || vpcs.length !== 1) {
+            this.addStandalone(file, logicalId, resource, 'database subnet group does not resolve to one VPC');
+            return;
+        }
+        vpcs[0].resources.push(Object.assign(Object.assign({}, this.topologyResource(file, logicalId, resource)), { placement: `DB subnet group ${subnetGroup.logicalId}: ${subnets.length} candidate subnets`, candidateSubnets: subnets, multiAz: ((_c = resource.Properties) === null || _c === void 0 ? void 0 : _c.MultiAZ) === true || resource.Type === 'AWS::RDS::DBCluster' }));
+    }
+    attachEcsService(file, logicalId, resource) {
+        var _a, _b, _c;
+        const subnetValues = (_c = (_b = (_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.NetworkConfiguration) === null || _b === void 0 ? void 0 : _b.AwsvpcConfiguration) === null || _c === void 0 ? void 0 : _c.Subnets;
+        if (!Array.isArray(subnetValues))
+            return;
+        const subnets = subnetValues
+            .map((value) => this.getSubnet(this.normalizeRef(value, file.fileIndex), file.fileIndex))
+            .filter((subnet) => Boolean(subnet));
+        const vpcs = uniqueByIdentity(subnets.flatMap((subnet) => {
+            const vpc = this.vpcForSubnet(subnet);
+            return vpc ? [vpc] : [];
+        }));
+        if (vpcs.length !== 1)
+            return;
+        vpcs[0].resources.push(Object.assign(Object.assign({}, this.topologyResource(file, logicalId, resource)), { placement: `ECS service: ${subnets.length} configured subnets`, candidateSubnets: subnets }));
+    }
+    attachInternetGateway(file) {
+        Object.values(file.cfnTemplate.Resources)
+            .filter((resource) => resource.Type === 'AWS::EC2::VPCGatewayAttachment')
+            .forEach((attachment) => {
+            var _a, _b;
+            const vpc = this.getVpc(this.normalizeRef((_a = attachment.Properties) === null || _a === void 0 ? void 0 : _a.VpcId, file.fileIndex), file.fileIndex);
+            const gateway = this.findTemplateResource(this.normalizeRef((_b = attachment.Properties) === null || _b === void 0 ? void 0 : _b.InternetGatewayId, file.fileIndex), file.fileIndex);
+            if (vpc && (gateway === null || gateway === void 0 ? void 0 : gateway.detail.Type) === 'AWS::EC2::InternetGateway') {
+                vpc.igw = {
+                    fileIndex: gateway.file.fileIndex,
+                    logicalId: gateway.logicalId,
+                };
+            }
+        });
+    }
+    collectLoadBalancers(file) {
+        Object.entries(file.cfnTemplate.Resources)
+            .filter(([, resource]) => resource.Type === 'AWS::ElasticLoadBalancingV2::LoadBalancer')
+            .forEach(([logicalId, resource]) => {
+            var _a, _b, _c, _d, _e;
+            const subnetValues = (_b = (_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.Subnets) !== null && _b !== void 0 ? _b : (_d = (_c = resource.Properties) === null || _c === void 0 ? void 0 : _c.SubnetMappings) === null || _d === void 0 ? void 0 : _d.map((mapping) => mapping.SubnetId);
+            if (!Array.isArray(subnetValues))
+                return;
+            const subnets = subnetValues
+                .map((value) => this.getSubnet(this.normalizeRef(value, file.fileIndex), file.fileIndex))
+                .filter((subnet) => Boolean(subnet));
+            const vpcs = uniqueByIdentity(subnets.flatMap((subnet) => {
+                const vpc = this.vpcForSubnet(subnet);
+                return vpc ? [vpc] : [];
+            }));
+            if (vpcs.length !== 1)
+                return;
+            const targetGroups = this.targetGroupsForLoadBalancer(file, logicalId);
+            vpcs[0].loadBalancers.push({
+                fileIndex: file.fileIndex,
+                logicalId,
+                internetFacing: ((_e = resource.Properties) === null || _e === void 0 ? void 0 : _e.Scheme) !== 'internal',
+                subnets,
+                targetGroups,
+                listeners: this.listenersForLoadBalancer(file, logicalId),
+            });
+        });
+    }
+    listenersForLoadBalancer(file, loadBalancerLogicalId) {
+        return Object.entries(file.cfnTemplate.Resources)
+            .filter(([, resource]) => {
+            var _a;
+            return resource.Type === 'AWS::ElasticLoadBalancingV2::Listener' &&
+                this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.LoadBalancerArn, file.fileIndex).value === loadBalancerLogicalId;
+        })
+            .map(([logicalId, listener]) => {
+            var _a, _b, _c;
+            const targetGroups = this.targetGroupsFromActions(file, Array.isArray((_a = listener.Properties) === null || _a === void 0 ? void 0 : _a.DefaultActions)
+                ? listener.Properties.DefaultActions
+                : []);
+            const rules = Object.entries(file.cfnTemplate.Resources)
+                .filter(([, resource]) => {
+                var _a;
+                return resource.Type === 'AWS::ElasticLoadBalancingV2::ListenerRule' &&
+                    this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.ListenerArn, file.fileIndex).value === logicalId;
+            })
+                .map(([ruleLogicalId, rule]) => {
+                var _a, _b, _c;
+                return ({
+                    fileIndex: file.fileIndex,
+                    logicalId: ruleLogicalId,
+                    conditions: listenerRuleConditions((_a = rule.Properties) === null || _a === void 0 ? void 0 : _a.Conditions),
+                    priority: displayProperty((_b = rule.Properties) === null || _b === void 0 ? void 0 : _b.Priority),
+                    targetGroups: this.targetGroupsFromActions(file, Array.isArray((_c = rule.Properties) === null || _c === void 0 ? void 0 : _c.Actions) ? rule.Properties.Actions : []),
+                });
+            });
+            return {
+                fileIndex: file.fileIndex,
+                logicalId,
+                protocol: displayProperty((_b = listener.Properties) === null || _b === void 0 ? void 0 : _b.Protocol),
+                port: displayProperty((_c = listener.Properties) === null || _c === void 0 ? void 0 : _c.Port),
+                targetGroups,
+                rules,
+            };
+        });
+    }
+    targetGroupsFromActions(file, actions) {
+        const targets = actions
+            .flatMap((action) => {
+            var _a;
+            return [
+                ...(action.TargetGroupArn ? [action.TargetGroupArn] : []),
+                ...(Array.isArray((_a = action.ForwardConfig) === null || _a === void 0 ? void 0 : _a.TargetGroups)
+                    ? action.ForwardConfig.TargetGroups.flatMap((target) => target.TargetGroupArn ? [target.TargetGroupArn] : [])
+                    : []),
+            ];
+        })
+            .map((value) => this.findTemplateResource(this.normalizeRef(value, file.fileIndex), file.fileIndex))
+            .filter((target) => Boolean(target && target.detail.Type === 'AWS::ElasticLoadBalancingV2::TargetGroup'));
+        return uniqueByIdentity(targets.map((target) => this.toTopologyTargetGroup(target)));
+    }
+    targetGroupsForLoadBalancer(file, loadBalancerLogicalId) {
+        const listeners = Object.entries(file.cfnTemplate.Resources)
+            .filter(([, resource]) => {
+            var _a;
+            return resource.Type === 'AWS::ElasticLoadBalancingV2::Listener' &&
+                this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.LoadBalancerArn, file.fileIndex).value === loadBalancerLogicalId;
+        });
+        const listenerIds = new Set(listeners.map(([logicalId]) => logicalId));
+        const listenerActions = listeners.flatMap(([, listener]) => {
+            var _a;
+            return Array.isArray((_a = listener.Properties) === null || _a === void 0 ? void 0 : _a.DefaultActions)
+                ? listener.Properties.DefaultActions
+                : [];
+        });
+        const listenerRuleActions = Object.values(file.cfnTemplate.Resources)
+            .filter((resource) => {
+            var _a;
+            return resource.Type === 'AWS::ElasticLoadBalancingV2::ListenerRule' &&
+                listenerIds.has(this.normalizeRef((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.ListenerArn, file.fileIndex).value);
+        })
+            .flatMap((rule) => { var _a; return Array.isArray((_a = rule.Properties) === null || _a === void 0 ? void 0 : _a.Actions) ? rule.Properties.Actions : []; });
+        const targetGroupResources = [...listenerActions, ...listenerRuleActions]
+            .flatMap((action) => {
+            var _a;
+            return [
+                ...(action.TargetGroupArn ? [action.TargetGroupArn] : []),
+                ...(Array.isArray((_a = action.ForwardConfig) === null || _a === void 0 ? void 0 : _a.TargetGroups)
+                    ? action.ForwardConfig.TargetGroups.flatMap((target) => target.TargetGroupArn ? [target.TargetGroupArn] : [])
+                    : []),
+            ];
+        })
+            .map((value) => this.findTemplateResource(this.normalizeRef(value, file.fileIndex), file.fileIndex))
+            .filter((target) => Boolean(target && target.detail.Type === 'AWS::ElasticLoadBalancingV2::TargetGroup'));
+        return uniqueByIdentity(targetGroupResources.map((targetGroup) => this.toTopologyTargetGroup(targetGroup)));
+    }
+    toTopologyTargetGroup(targetGroup) {
+        var _a, _b, _c, _d;
+        const staticTargets = Array.isArray((_a = targetGroup.detail.Properties) === null || _a === void 0 ? void 0 : _a.Targets)
+            ? targetGroup.detail.Properties.Targets.map((target) => ({
+                sourceFileIndex: targetGroup.file.fileIndex,
+                logicalId: this.normalizeRef(target.Id, targetGroup.file.fileIndex),
+            }))
+            : [];
+        const ecsTargets = this.diagramFiles.flatMap((candidateFile) => Object.entries(candidateFile.cfnTemplate.Resources).flatMap(([logicalId, resource]) => {
+            var _a;
+            if (resource.Type !== 'AWS::ECS::Service' || !Array.isArray((_a = resource.Properties) === null || _a === void 0 ? void 0 : _a.LoadBalancers)) {
+                return [];
+            }
+            const matches = resource.Properties.LoadBalancers.some((binding) => {
+                const resolved = this.findTemplateResource(this.normalizeRef(binding.TargetGroupArn, candidateFile.fileIndex), candidateFile.fileIndex);
+                return (resolved === null || resolved === void 0 ? void 0 : resolved.file.fileIndex) === targetGroup.file.fileIndex &&
+                    resolved.logicalId === targetGroup.logicalId;
+            });
+            return matches ? [{
+                    sourceFileIndex: candidateFile.fileIndex,
+                    logicalId: this.normalizeRef({ Ref: logicalId }, candidateFile.fileIndex),
+                }] : [];
+        }));
+        return {
+            fileIndex: targetGroup.file.fileIndex,
+            logicalId: targetGroup.logicalId,
+            protocol: displayProperty((_b = targetGroup.detail.Properties) === null || _b === void 0 ? void 0 : _b.Protocol),
+            port: displayProperty((_c = targetGroup.detail.Properties) === null || _c === void 0 ? void 0 : _c.Port),
+            targetType: displayProperty((_d = targetGroup.detail.Properties) === null || _d === void 0 ? void 0 : _d.TargetType),
+            targets: [...staticTargets, ...ecsTargets],
+        };
+    }
+    topologyResource(file, logicalId, detail) {
+        var _a;
+        return {
+            fileIndex: file.fileIndex,
+            logicalId,
+            exportedName: (_a = file.outputs.find((output) => output.value.logicalId === logicalId)) === null || _a === void 0 ? void 0 : _a.export.rawName,
+            detail,
+        };
+    }
+    addStandalone(file, logicalId, detail, reason) {
+        console.warn(`${file.fileName}:${logicalId} ${reason} - rendering it standalone.`);
+        this.standaloneResources.push({ fileIndex: file.fileIndex, logicalId, detail });
+    }
+    normalizeRef(value, sourceFileIndex) {
+        var _a, _b;
+        const parsed = (0, intrinsics_1.parseRefValue)(value);
+        if (parsed.type !== 'ImportValue')
+            return parsed;
+        const importExpression = (_a = value === null || value === void 0 ? void 0 : value['Fn::ImportValue']) !== null && _a !== void 0 ? _a : value === null || value === void 0 ? void 0 : value['!ImportValue'];
+        const sourceFile = this.diagramFiles[sourceFileIndex];
+        return Object.assign(Object.assign({}, parsed), { value: (_b = (0, intrinsics_1.resolveCfnString)(importExpression, {
+                parameters: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.cfnTemplate.Parameters,
+                parameterValues: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.parameterValues,
+                pseudoParameters: sourceFile ? Object.assign({ 'AWS::StackName': sourceFile.groupName }, sourceFile.pseudoParameterValues) : undefined,
+            })) !== null && _b !== void 0 ? _b : parsed.value });
+    }
+    findTemplateResource(reference, sourceFileIndex) {
+        if (reference.type === 'ImportValue') {
+            for (const file of this.diagramFiles) {
+                const output = file.outputs.find((candidate) => candidate.export.rawName === reference.value);
+                if (output) {
+                    const detail = file.cfnTemplate.Resources[output.value.logicalId];
+                    if (detail)
+                        return { file, logicalId: output.value.logicalId, detail };
+                }
+            }
+            return undefined;
+        }
+        const file = this.diagramFiles[sourceFileIndex];
+        const detail = file === null || file === void 0 ? void 0 : file.cfnTemplate.Resources[reference.value];
+        return detail ? { file, logicalId: reference.value, detail } : undefined;
+    }
+    getVpc(reference, sourceFileIndex) {
+        return this.vpcs.find((vpc) => reference.type === 'ImportValue'
+            ? vpc.exportedName === reference.value
+            : vpc.fileIndex === sourceFileIndex && vpc.logicalId === reference.value);
+    }
+    getSubnet(reference, sourceFileIndex) {
+        return this.allSubnets().find((subnet) => reference.type === 'ImportValue'
+            ? subnet.exportedName === reference.value
+            : subnet.fileIndex === sourceFileIndex && subnet.logicalId === reference.value);
+    }
+    resourceMatches(resource, reference, sourceFileIndex) {
+        return reference.type === 'ImportValue'
+            ? resource.exportedName === reference.value
+            : resource.fileIndex === sourceFileIndex && resource.logicalId === reference.value;
+    }
+    vpcForSubnet(target) {
+        return this.vpcs.find((vpc) => vpc.availabilityZones.some((az) => az.subnets.includes(target)));
+    }
+    allSubnets() {
+        return this.vpcs.flatMap((vpc) => vpc.availabilityZones.flatMap((az) => az.subnets));
+    }
+}
+exports.CfnArchitectureDiagramStructure = CfnArchitectureDiagramStructure;
+//# sourceMappingURL=architectureTopology.js.map