@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/vpc/models/routeTable.js

@@ -0,0 +1,160 @@
+/**
+ * Route Table Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Route {
+  constructor(destinationCidrBlock, target, targetType = 'local') {
+    this.DestinationCidrBlock = destinationCidrBlock;
+    this.State = 'active';
+    this.Origin = 'CreateRouteTable';
+    this.CreatedAt = new Date().toISOString();
+    
+    // Set target based on type
+    switch (targetType) {
+      case 'local':
+        this.Target = 'local';
+        break;
+      case 'igw':
+        this.GatewayId = target;
+        this.Target = target;
+        break;
+      case 'nat':
+        this.NatGatewayId = target;
+        this.Target = target;
+        break;
+      case 'vpce':
+        this.VpcEndpointId = target;
+        this.Target = target;
+        break;
+      case 'instance':
+        this.InstanceId = target;
+        this.Target = target;
+        break;
+      case 'eni':
+        this.NetworkInterfaceId = target;
+        this.Target = target;
+        break;
+      default:
+        this.GatewayId = target;
+        this.Target = target;
+    }
+  }
+
+  toJSON() {
+    const result = {
+      DestinationCidrBlock: this.DestinationCidrBlock,
+      State: this.State,
+      Origin: this.Origin
+    };
+
+    if (this.GatewayId) result.GatewayId = this.GatewayId;
+    if (this.NatGatewayId) result.NatGatewayId = this.NatGatewayId;
+    if (this.VpcEndpointId) result.VpcEndpointId = this.VpcEndpointId;
+    if (this.InstanceId) result.InstanceId = this.InstanceId;
+    if (this.NetworkInterfaceId) result.NetworkInterfaceId = this.NetworkInterfaceId;
+
+    return result;
+  }
+}
+
+class RouteTableAssociation {
+  constructor(subnetId, routeTableId, isMain = false) {
+    this.RouteTableAssociationId = `rtbassoc-${uuidv4().substring(0, 8)}`;
+    this.SubnetId = subnetId;
+    this.RouteTableId = routeTableId;
+    this.Main = isMain;
+    this.CreatedAt = new Date().toISOString();
+  }
+
+  toJSON() {
+    return {
+      RouteTableAssociationId: this.RouteTableAssociationId,
+      SubnetId: this.SubnetId,
+      RouteTableId: this.RouteTableId,
+      Main: this.Main
+    };
+  }
+}
+
+class RouteTable {
+  constructor(vpcId, tags = [], isMain = false) {
+    this.RouteTableId = `rtb-${uuidv4().substring(0, 8)}`;
+    this.VpcId = vpcId;
+    this.Routes = [];
+    this.Associations = [];
+    this.Tags = tags;
+    this.IsMain = isMain;
+    this.State = 'active';
+    this.CreatedAt = new Date().toISOString();
+
+    // Local route é adicionada automaticamente
+    this.addLocalRoute(vpcId);
+  }
+
+  addLocalRoute(vpcCidr) {
+    const localRoute = new Route(vpcCidr, 'local', 'local');
+    this.Routes.push(localRoute);
+  }
+
+  addRoute(destinationCidrBlock, target, targetType = 'igw') {
+    // Verificar se rota já existe
+    const exists = this.Routes.some(r => r.DestinationCidrBlock === destinationCidrBlock);
+    if (exists) {
+      throw new Error(`Route with destination ${destinationCidrBlock} already exists`);
+    }
+
+    const route = new Route(destinationCidrBlock, target, targetType);
+    this.Routes.push(route);
+    return route;
+  }
+
+  removeRoute(destinationCidrBlock) {
+    const index = this.Routes.findIndex(r => r.DestinationCidrBlock === destinationCidrBlock);
+    if (index === -1) {
+      throw new Error(`Route with destination ${destinationCidrBlock} not found`);
+    }
+
+    const route = this.Routes[index];
+    this.Routes.splice(index, 1);
+    return route;
+  }
+
+  addAssociation(subnetId) {
+    const exists = this.Associations.some(a => a.SubnetId === subnetId);
+    if (exists) {
+      throw new Error(`Subnet ${subnetId} is already associated with this route table`);
+    }
+
+    const association = new RouteTableAssociation(subnetId, this.RouteTableId);
+    this.Associations.push(association);
+    return association;
+  }
+
+  removeAssociation(subnetId) {
+    const index = this.Associations.findIndex(a => a.SubnetId === subnetId);
+    if (index === -1) {
+      throw new Error(`Subnet ${subnetId} is not associated with this route table`);
+    }
+
+    const association = this.Associations[index];
+    this.Associations.splice(index, 1);
+    return association;
+  }
+
+  toJSON() {
+    return {
+      RouteTableId: this.RouteTableId,
+      VpcId: this.VpcId,
+      Routes: this.Routes.map(r => r.toJSON()),
+      Associations: this.Associations.map(a => a.toJSON()),
+      Tags: this.Tags,
+      IsMain: this.IsMain,
+      State: this.State,
+      CreatedAt: this.CreatedAt
+    };
+  }
+}
+
+module.exports = { RouteTable, Route, RouteTableAssociation };

package/src/services/vpc/models/subnet.js

@@ -0,0 +1,48 @@
+/**
+ * Subnet Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Subnet {
+  constructor(vpcId, cidrBlock, availabilityZone, tags = [], config = {}) {
+    this.SubnetId = `subnet-${uuidv4().substring(0, 8)}`;
+    this.VpcId = vpcId;
+    this.CidrBlock = cidrBlock;
+    this.AvailabilityZone = availabilityZone;
+    this.State = 'available';
+    this.AvailableIpAddressCount = this.calculateAvailableIps(cidrBlock);
+    this.MapPublicIpOnLaunch = config.MapPublicIpOnLaunch || false;
+    this.Tags = tags;
+    this.CreatedAt = new Date().toISOString();
+    this.AssignIpv6AddressOnCreation = config.AssignIpv6AddressOnCreation || false;
+  }
+
+  calculateAvailableIps(cidrBlock) {
+    // Simples cálculo: /24 = 256 - 5 (reservados AWS) = 251
+    const parts = cidrBlock.split('/');
+    if (parts.length === 2) {
+      const prefixLength = parseInt(parts[1]);
+      const totalIps = Math.pow(2, 32 - prefixLength);
+      return Math.max(1, totalIps - 5); // AWS reserva 5 IPs
+    }
+    return 250;
+  }
+
+  toJSON() {
+    return {
+      SubnetId: this.SubnetId,
+      VpcId: this.VpcId,
+      CidrBlock: this.CidrBlock,
+      AvailabilityZone: this.AvailabilityZone,
+      State: this.State,
+      AvailableIpAddressCount: this.AvailableIpAddressCount,
+      MapPublicIpOnLaunch: this.MapPublicIpOnLaunch,
+      Tags: this.Tags,
+      CreatedAt: this.CreatedAt,
+      AssignIpv6AddressOnCreation: this.AssignIpv6AddressOnCreation
+    };
+  }
+}
+
+module.exports = Subnet;

package/src/services/vpc/models/vpc.js

@@ -0,0 +1,37 @@
+/**
+ * VPC Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class VPC {
+  constructor(cidrBlock, tags = [], config = {}) {
+    this.VpcId = `vpc-${uuidv4().substring(0, 8)}`;
+    this.CidrBlock = cidrBlock;
+    this.State = 'available';
+    this.IsDefault = false;
+    this.Tags = tags;
+    this.CreatedAt = new Date().toISOString();
+    this.Ipv6CidrBlockAssociationSet = [];
+    this.EnableDnsHostnames = config.EnableDnsHostnames !== false;
+    this.EnableDnsSupport = config.EnableDnsSupport !== false;
+    this.InstanceTenancy = config.InstanceTenancy || 'default';
+  }
+
+  toJSON() {
+    return {
+      VpcId: this.VpcId,
+      CidrBlock: this.CidrBlock,
+      State: this.State,
+      IsDefault: this.IsDefault,
+      Tags: this.Tags,
+      CreatedAt: this.CreatedAt,
+      Ipv6CidrBlockAssociationSet: this.Ipv6CidrBlockAssociationSet,
+      EnableDnsHostnames: this.EnableDnsHostnames,
+      EnableDnsSupport: this.EnableDnsSupport,
+      InstanceTenancy: this.InstanceTenancy
+    };
+  }
+}
+
+module.exports = VPC;

package/src/services/vpc/models/vpcEndpoint.js

@@ -0,0 +1,100 @@
+/**
+ * VPC Endpoint Model
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class VPCEndpoint {
+  constructor(vpcId, serviceName, config = {}) {
+    this.VpcEndpointId = `vpce-${uuidv4().substring(0, 8)}`;
+    this.VpcId = vpcId;
+    this.ServiceName = serviceName;
+    this.VpcEndpointType = config.VpcEndpointType || 'Gateway';
+    this.State = 'available';
+    this.CreationTimestamp = new Date().toISOString();
+    
+    // Para Gateway endpoints (S3, DynamoDB)
+    this.RouteTableIds = config.RouteTableIds || [];
+    
+    // Para Interface endpoints
+    this.SubnetIds = config.SubnetIds || [];
+    this.SecurityGroupIds = config.SecurityGroupIds || [];
+    this.PrivateDnsEnabled = config.PrivateDnsEnabled || false;
+    this.NetworkInterfaceIds = config.NetworkInterfaceIds || [];
+    
+    this.PolicyDocument = config.PolicyDocument || {
+      Statement: [
+        {
+          Effect: 'Allow',
+          Principal: '*',
+          Action: '*',
+          Resource: '*'
+        }
+      ]
+    };
+    
+    this.Tags = config.Tags || [];
+  }
+
+  addRouteTable(routeTableId) {
+    if (!this.RouteTableIds.includes(routeTableId)) {
+      this.RouteTableIds.push(routeTableId);
+    }
+  }
+
+  removeRouteTable(routeTableId) {
+    const index = this.RouteTableIds.indexOf(routeTableId);
+    if (index > -1) {
+      this.RouteTableIds.splice(index, 1);
+    }
+  }
+
+  addSubnet(subnetId) {
+    if (!this.SubnetIds.includes(subnetId)) {
+      this.SubnetIds.push(subnetId);
+    }
+  }
+
+  removeSubnet(subnetId) {
+    const index = this.SubnetIds.indexOf(subnetId);
+    if (index > -1) {
+      this.SubnetIds.splice(index, 1);
+    }
+  }
+
+  getServiceType() {
+    if (this.ServiceName.includes('.s3')) return 'S3';
+    if (this.ServiceName.includes('.dynamodb')) return 'DynamoDB';
+    if (this.ServiceName.includes('.lambda')) return 'Lambda';
+    if (this.ServiceName.includes('.sqs')) return 'SQS';
+    if (this.ServiceName.includes('.sns')) return 'SNS';
+    if (this.ServiceName.includes('.ec2')) return 'EC2';
+    return 'Custom';
+  }
+
+  toJSON() {
+    const result = {
+      VpcEndpointId: this.VpcEndpointId,
+      VpcId: this.VpcId,
+      ServiceName: this.ServiceName,
+      VpcEndpointType: this.VpcEndpointType,
+      State: this.State,
+      CreationTimestamp: this.CreationTimestamp,
+      PolicyDocument: this.PolicyDocument,
+      Tags: this.Tags
+    };
+
+    if (this.VpcEndpointType === 'Gateway') {
+      result.RouteTableIds = this.RouteTableIds;
+    } else if (this.VpcEndpointType === 'Interface') {
+      result.SubnetIds = this.SubnetIds;
+      result.SecurityGroupIds = this.SecurityGroupIds;
+      result.PrivateDnsEnabled = this.PrivateDnsEnabled;
+      result.NetworkInterfaceIds = this.NetworkInterfaceIds;
+    }
+
+    return result;
+  }
+}
+
+module.exports = VPCEndpoint;

package/src/services/vpc/models/vpcGateway.js

@@ -0,0 +1,134 @@
+/**
+ * VPC Gateway Model (NAT Gateway, Customer Gateway, etc)
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class NATGateway {
+  constructor(subnetId, allocationId, config = {}) {
+    this.NatGatewayId = `natgw-${uuidv4().substring(0, 8)}`;
+    this.SubnetId = subnetId;
+    this.AllocationId = allocationId;
+    this.PublicIp = config.PublicIp || `192.0.2.${Math.floor(Math.random() * 256)}`;
+    this.PrivateIp = config.PrivateIp || null;
+    this.State = 'available';
+    this.CreateTime = new Date().toISOString();
+    this.Tags = config.Tags || [];
+  }
+
+  toJSON() {
+    return {
+      NatGatewayId: this.NatGatewayId,
+      SubnetId: this.SubnetId,
+      AllocationId: this.AllocationId,
+      PublicIp: this.PublicIp,
+      PrivateIp: this.PrivateIp,
+      State: this.State,
+      CreateTime: this.CreateTime,
+      Tags: this.Tags
+    };
+  }
+}
+
+class CustomerGateway {
+  constructor(type, bgpAsn, config = {}) {
+    this.CustomerGatewayId = `cgw-${uuidv4().substring(0, 8)}`;
+    this.Type = type; // ipsec.1
+    this.BgpAsn = bgpAsn;
+    this.IpAddress = config.IpAddress || null;
+    this.State = 'available';
+    this.CreateTime = new Date().toISOString();
+    this.Tags = config.Tags || [];
+  }
+
+  toJSON() {
+    return {
+      CustomerGatewayId: this.CustomerGatewayId,
+      Type: this.Type,
+      BgpAsn: this.BgpAsn,
+      IpAddress: this.IpAddress,
+      State: this.State,
+      CreateTime: this.CreateTime,
+      Tags: this.Tags
+    };
+  }
+}
+
+class VpnGateway {
+  constructor(type, config = {}) {
+    this.VpnGatewayId = `vgw-${uuidv4().substring(0, 8)}`;
+    this.Type = type; // ipsec.1
+    this.State = 'available';
+    this.VpcAttachments = config.VpcAttachments || [];
+    this.CreateTime = new Date().toISOString();
+    this.Tags = config.Tags || [];
+  }
+
+  attachToVpc(vpcId) {
+    const exists = this.VpcAttachments.some(a => a.VpcId === vpcId);
+    if (exists) {
+      throw new Error(`VPN Gateway already attached to VPC ${vpcId}`);
+    }
+
+    this.VpcAttachments.push({
+      VpcId: vpcId,
+      State: 'attached'
+    });
+  }
+
+  detachFromVpc(vpcId) {
+    const index = this.VpcAttachments.findIndex(a => a.VpcId === vpcId);
+    if (index === -1) {
+      throw new Error(`VPN Gateway not attached to VPC ${vpcId}`);
+    }
+
+    this.VpcAttachments.splice(index, 1);
+  }
+
+  toJSON() {
+    return {
+      VpnGatewayId: this.VpnGatewayId,
+      Type: this.Type,
+      State: this.State,
+      VpcAttachments: this.VpcAttachments,
+      CreateTime: this.CreateTime,
+      Tags: this.Tags
+    };
+  }
+}
+
+class VpnConnection {
+  constructor(type, customerGatewayId, vpnGatewayId, config = {}) {
+    this.VpnConnectionId = `vpn-${uuidv4().substring(0, 8)}`;
+    this.Type = type; // ipsec.1
+    this.CustomerGatewayId = customerGatewayId;
+    this.VpnGatewayId = vpnGatewayId;
+    this.State = 'available';
+    this.Options = config.Options || {
+      StaticRoutesOnly: false,
+      TunnelOptions: []
+    };
+    this.CreateTime = new Date().toISOString();
+    this.Tags = config.Tags || [];
+  }
+
+  toJSON() {
+    return {
+      VpnConnectionId: this.VpnConnectionId,
+      Type: this.Type,
+      CustomerGatewayId: this.CustomerGatewayId,
+      VpnGatewayId: this.VpnGatewayId,
+      State: this.State,
+      Options: this.Options,
+      CreateTime: this.CreateTime,
+      Tags: this.Tags
+    };
+  }
+}
+
+module.exports = {
+  NATGateway,
+  CustomerGateway,
+  VpnGateway,
+  VpnConnection
+};