@csermet/multiprovider
Version:
cloud-graph provider plugin for AWS used to fetch AWS cloud data.
277 lines (276 loc) • 10.8 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const sdk_1 = require("@cloudgraph/sdk");
const services_1 = __importDefault(require("../../enums/services"));
const generateArns_1 = require("../../utils/generateArns");
/**
* VPCs
*/
exports.default = ({ account, service: vpc, data, region, }) => {
const { VpcId: id } = vpc;
const connections = [];
const ec2s = data.find(({ name }) => name === services_1.default.ec2Instance);
const ec2sRunningInVpc = ec2s?.data?.[region]?.filter(({ VpcId }) => VpcId === id) || [];
const ec2InstancesIdsRunningInVpc = ec2sRunningInVpc?.map(ec2 => ec2.InstanceId) || [];
const sgs = data.find(({ name }) => name === services_1.default.sg);
const sgIds = sgs?.data?.[region]?.map(({ GroupId }) => GroupId) || [];
const subnets = data.find(({ name }) => name === services_1.default.subnet);
const subnetIds = subnets?.data?.[region]?.map(({ SubnetId }) => SubnetId) || [];
/**
* Find any ALB Instances
*/
const albInstances = data.find(({ name }) => name === services_1.default.alb);
if (albInstances?.data?.[region]) {
const dataAtRegion = albInstances.data[region].filter(({ VpcId: vpcId }) => vpcId === id);
for (const instance of dataAtRegion) {
connections.push({
id: instance.LoadBalancerArn,
resourceType: services_1.default.alb,
relation: 'child',
field: 'albs',
});
}
}
/**
* Find any DMS replication instance related data
*/
const replications = data.find(({ name }) => name === services_1.default.dmsReplicationInstance);
if (replications?.data?.[region]) {
const dataAtRegion = replications.data[region].filter(({ ReplicationSubnetGroup = {} }) => {
const vpcId = ReplicationSubnetGroup.VpcId;
return id === vpcId;
});
for (const instance of dataAtRegion) {
connections.push({
id: instance.ReplicationInstanceArn,
resourceType: services_1.default.dmsReplicationInstance,
relation: 'child',
field: 'dmsReplicationInstances',
});
}
}
/**
* Find any ECS service related data
*/
const ecsServices = data.find(({ name }) => name === services_1.default.ecsService);
if (ecsServices?.data?.[region]) {
const dataAtRegion = ecsServices.data[region].filter(({ networkConfiguration }) => {
const sgIds = networkConfiguration?.awsvpcConfiguration?.securityGroups || [];
return sgIds.includes(id);
});
for (const instance of dataAtRegion) {
connections.push({
id: instance.serviceArn,
resourceType: services_1.default.ecsService,
relation: 'child',
field: 'ecsServices',
});
}
}
/**
* Find any EIP related data
*/
const eips = data.find(({ name }) => name === services_1.default.eip);
if (eips?.data?.[region]) {
const dataAtRegion = eips.data[region].filter(({ Domain, InstanceId }) => Domain === 'vpc' && ec2InstancesIdsRunningInVpc?.includes(InstanceId));
for (const eip of dataAtRegion) {
connections.push({
id: eip.AllocationId,
resourceType: services_1.default.eip,
relation: 'child',
field: 'eips',
});
}
}
/**
* Find any elasticSearchDomain related data
*/
const domains = data.find(({ name }) => name === services_1.default.elasticSearchDomain);
if (domains?.data?.[region]) {
const dataAtRegion = domains.data[region].filter(({ VPCOptions }) => VPCOptions.VPCId === id);
for (const domain of dataAtRegion) {
connections.push({
id: domain.DomainId,
resourceType: services_1.default.elasticSearchDomain,
relation: 'child',
field: 'elasticSearchDomains',
});
}
}
/**
* Find any EKS cluster related data
*/
const eksClusters = data.find(({ name }) => name === services_1.default.eksCluster);
if (eksClusters?.data?.[region]) {
const dataAtRegion = eksClusters.data[region].filter(({ resourcesVpcConfig: { vpcId } }) => vpcId === id);
for (const eksCluster of dataAtRegion) {
connections.push({
id: eksCluster.arn,
resourceType: services_1.default.eksCluster,
relation: 'child',
field: 'eksClusters',
});
}
}
/**
* Find any FlowLog related data
*/
const flowLogs = data.find(({ name }) => name === services_1.default.flowLog);
if (flowLogs?.data?.[region]) {
const dataAtRegion = flowLogs.data[region].filter(({ ResourceId }) => ResourceId === id);
for (const flowLog of dataAtRegion) {
connections.push({
id: flowLog.FlowLogId,
resourceType: services_1.default.flowLog,
relation: 'child',
field: 'flowLog',
});
}
}
/**
* Find any IGW related data
*/
const igws = data.find(({ name }) => name === services_1.default.igw);
if (igws?.data?.[region]) {
const dataAtRegion = igws.data[region].filter(({ Attachments }) => Attachments.find(({ VpcId }) => VpcId === id));
for (const igw of dataAtRegion) {
connections.push({
id: igw.InternetGatewayId,
resourceType: services_1.default.igw,
relation: 'child',
field: 'igws',
});
}
}
/**
* Find any Lambda related data
*/
const lambdas = data.find(({ name }) => name === services_1.default.lambda);
if (lambdas?.data?.[region]) {
const dataAtRegion = lambdas.data[region].filter(({ VpcConfig: { VpcId, SecurityGroupIds, SubnetIds } = {}, }) => {
return (VpcId === id ||
sdk_1.intersectStringArrays(sgIds, SecurityGroupIds).length > 0 ||
sdk_1.intersectStringArrays(subnetIds, SubnetIds).length > 0);
});
for (const lambda of dataAtRegion) {
connections.push({
id: lambda.FunctionArn,
resourceType: services_1.default.lambda,
relation: 'child',
field: 'lambdas',
});
}
}
/**
* Find any NAT related data
*/
const nats = data.find(({ name }) => name === services_1.default.nat);
if (nats?.data?.[region]) {
const dataAtRegion = nats.data[region].filter(({ VpcId, SubnetId }) => VpcId === id || subnetIds.includes(SubnetId));
for (const nat of dataAtRegion) {
connections.push({
id: nat.NatGatewayId,
resourceType: services_1.default.nat,
relation: 'child',
field: 'natGateways',
});
}
}
/**
* Find any Network Interface related data
*/
const netInterfaces = data.find(({ name }) => name === services_1.default.networkInterface);
if (netInterfaces?.data?.[region]) {
const dataAtRegion = netInterfaces.data[region].filter(({ VpcId, SubnetId }) => VpcId === id || subnetIds.includes(SubnetId));
for (const net of dataAtRegion) {
connections.push({
id: net.NetworkInterfaceId,
resourceType: services_1.default.networkInterface,
relation: 'child',
field: 'networkInterfaces',
});
}
}
/**
* Find any RDS Instance related data
*/
const rdsDbInstances = data.find(({ name }) => name === services_1.default.rdsDbInstance);
if (rdsDbInstances?.data?.[region] && sgs?.data?.[region]) {
const dataAtRegion = rdsDbInstances.data[region].filter(({ DBSubnetGroup: { VpcId } = {} }) => VpcId === id);
for (const rds of dataAtRegion) {
connections.push({
id: rds.DBInstanceArn,
resourceType: services_1.default.rdsDbInstance,
relation: 'child',
field: 'rdsDbInstances',
});
}
}
/**
* Find any RDS Cluster Snapshot related data
*/
const snapshots = data.find(({ name }) => name === services_1.default.rdsClusterSnapshot);
if (snapshots?.data?.[region]) {
const dataAtRegion = snapshots.data[region].filter(({ VpcId }) => VpcId === id);
for (const snapshot of dataAtRegion) {
connections.push({
id: snapshot.DBClusterSnapshotIdentifier,
resourceType: services_1.default.rdsClusterSnapshot,
relation: 'child',
field: 'rdsClusterSnapshots',
});
}
}
/**
* Find any Subnet related data
*/
if (subnets?.data?.[region]) {
const dataAtRegion = subnets.data[region].filter(({ VpcId }) => VpcId === id);
for (const subnet of dataAtRegion) {
connections.push({
id: subnet.SubnetId,
resourceType: services_1.default.subnet,
relation: 'child',
field: 'subnets',
});
}
}
/**
* Find any ELB Instances
*/
const elbInstances = data.find(({ name }) => name === services_1.default.elb);
if (elbInstances?.data?.[region]) {
const dataAtRegion = elbInstances.data[region].filter(({ VPCId: vpcId }) => vpcId === id);
for (const instance of dataAtRegion) {
const { LoadBalancerName: loadBalancerName } = instance;
connections.push({
id: generateArns_1.elbArn({ region, account, name: loadBalancerName }),
resourceType: services_1.default.elb,
relation: 'child',
field: 'elbs',
});
}
}
/**
* Find any Network ACL
*/
const nacls = data.find(({ name }) => name === services_1.default.nacl);
if (nacls?.data?.[region]) {
const dataAtRegion = nacls.data[region].filter(({ VpcId: vpcId }) => vpcId === id);
for (const instance of dataAtRegion) {
connections.push({
id: instance.NetworkAclId,
resourceType: services_1.default.nacl,
relation: 'child',
field: 'nacls',
});
}
}
const VpcResult = {
[id]: connections,
};
return VpcResult;
};