@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/alb/simulator.js

@@ -0,0 +1,262 @@
+/**
+ * ALB Simulator - Application Load Balancer com persistência
+ */
+
+const path = require('path');
+const LoadBalancer = require('./models/loadBalancer');
+const { TargetGroup } = require('./models/targetGroup');
+const LocalStore = require('../../utils/local-store');
+const logger = require('../../utils/logger');
+
+class ALBSimulator {
+  constructor(config = {}) {
+    this.config = config;
+    this.loadBalancers = new Map();
+    this.targetGroups = new Map();
+
+    // Inicializar persistência
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || './.aws-local-simulator-data';
+    this.dataDir = path.join(dataDir, 'alb');
+    this.store = new LocalStore(this.dataDir);
+  }
+
+  async initialize() {
+    // 1. Carregar dados persistidos
+    await this.loadFromPersistence();
+
+    // 2. Pré-provisionar ALBs se configurado e não existirem
+    if (this.loadBalancers.size === 0 && this.config.loadBalancers && Array.isArray(this.config.loadBalancers)) {
+      logger.info('📚 Carregando ALBs da configuração inicial...');
+      for (const albConfig of this.config.loadBalancers) {
+        this.createLoadBalancer(albConfig.Name, 'internet-facing', albConfig);
+      }
+    }
+  }
+
+  /**
+   * Carrega dados persistidos do storage
+   */
+  async loadFromPersistence() {
+    try {
+      // Carregar Load Balancers
+      const albsData = this.store.read('load-balancers');
+      if (Array.isArray(albsData)) {
+        logger.info(`📂 Carregando ${albsData.length} ALBs do storage...`);
+        for (const albData of albsData) {
+          const alb = new LoadBalancer(albData.LoadBalancerName, albData.Scheme, albData);
+          alb.LoadBalancerArn = albData.LoadBalancerArn;
+          alb.State = albData.State;
+          alb.Listeners = albData.Listeners || [];
+          this.loadBalancers.set(alb.LoadBalancerArn, alb);
+        }
+      }
+
+      // Carregar Target Groups
+      const tgsData = this.store.read('target-groups');
+      if (Array.isArray(tgsData)) {
+        logger.info(`📂 Carregando ${tgsData.length} Target Groups do storage...`);
+        for (const tgData of tgsData) {
+          const tg = new TargetGroup(tgData.TargetGroupName, tgData.Protocol, tgData.Port, tgData.VpcId);
+          tg.TargetGroupArn = tgData.TargetGroupArn;
+          tg.Targets = tgData.Targets || [];
+          tg.HealthCheckConfig = tgData.HealthCheckConfig || {};
+          this.targetGroups.set(tg.TargetGroupArn, tg);
+        }
+      }
+    } catch (error) {
+      logger.warn(`⚠️  Erro ao carregar dados persistidos ALB: ${error.message}`);
+    }
+  }
+
+  /**
+   * Persiste estado atual em storage
+   */
+  persistData() {
+    try {
+      this.store.write('load-balancers', Array.from(this.loadBalancers.values()).map(a => a.toJSON ? a.toJSON() : a));
+      this.store.write('target-groups', Array.from(this.targetGroups.values()).map(tg => tg.toJSON ? tg.toJSON() : tg));
+    } catch (error) {
+      logger.error(`Erro ao persistir dados ALB: ${error.message}`);
+    }
+  }
+
+  // ========== Load Balancer Operations ==========
+
+  createLoadBalancer(name, scheme = 'internet-facing', config = {}) {
+    const alb = new LoadBalancer(name, scheme, config);
+    this.loadBalancers.set(alb.LoadBalancerArn, alb);
+    logger.info(`✅ ALB criado: ${name} (${alb.LoadBalancerArn})`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return alb;
+  }
+
+  describeLoadBalancers(filters = {}) {
+    let albs = Array.from(this.loadBalancers.values());
+
+    if (filters.names && Array.isArray(filters.names)) {
+      albs = albs.filter(a => filters.names.includes(a.LoadBalancerName));
+    }
+
+    if (filters.arns && Array.isArray(filters.arns)) {
+      albs = albs.filter(a => filters.arns.includes(a.LoadBalancerArn));
+    }
+
+    return albs;
+  }
+
+  getLoadBalancer(albArn) {
+    const alb = this.loadBalancers.get(albArn);
+    if (!alb) {
+      throw new Error(`Load Balancer ${albArn} not found`);
+    }
+    return alb;
+  }
+
+  deleteLoadBalancer(albArn) {
+    // Deletar target groups associados
+    const alb = this.getLoadBalancer(albArn);
+    alb.TargetGroups.forEach(tg => {
+      this.targetGroups.delete(tg.TargetGroupArn);
+    });
+
+    this.loadBalancers.delete(albArn);
+    logger.info(`🗑️ ALB deletado: ${albArn}`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return true;
+  }
+
+  // ========== Target Group Operations ==========
+
+  createTargetGroup(name, protocol = 'HTTP', port = 80, vpcId = null, config = {}) {
+    const tg = new TargetGroup(name, protocol, port, vpcId, config);
+    this.targetGroups.set(tg.TargetGroupArn, tg);
+    logger.info(`✅ Target Group criado: ${name} (${tg.TargetGroupArn})`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return tg;
+  }
+
+  describeTargetGroups(filters = {}) {
+    let tgs = Array.from(this.targetGroups.values());
+
+    if (filters.names && Array.isArray(filters.names)) {
+      tgs = tgs.filter(t => filters.names.includes(t.TargetGroupName));
+    }
+
+    if (filters.arns && Array.isArray(filters.arns)) {
+      tgs = tgs.filter(t => filters.arns.includes(t.TargetGroupArn));
+    }
+
+    return tgs;
+  }
+
+  getTargetGroup(tgArn) {
+    const tg = this.targetGroups.get(tgArn);
+    if (!tg) {
+      throw new Error(`Target Group ${tgArn} not found`);
+    }
+    return tg;
+  }
+
+  deleteTargetGroup(tgArn) {
+    // Verificar se está em uso por ALB
+    const inUse = Array.from(this.loadBalancers.values()).some(alb =>
+      alb.TargetGroups.some(tg => tg.TargetGroupArn === tgArn)
+    );
+
+    if (inUse) {
+      throw new Error(`Target Group ${tgArn} still in use by load balancer`);
+    }
+
+    this.targetGroups.delete(tgArn);
+    logger.info(`🗑️ Target Group deletado: ${tgArn}`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return true;
+  }
+
+  // ========== Target Operations ==========
+
+  registerTarget(tgArn, targetId, port = null) {
+    const tg = this.getTargetGroup(tgArn);
+    const target = tg.registerTarget(targetId, port);
+    logger.info(`✅ Target registrado: ${targetId} em ${tg.TargetGroupName}`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return target;
+  }
+
+  deregisterTarget(tgArn, targetId, port = null) {
+    const tg = this.getTargetGroup(tgArn);
+    const target = tg.deregisterTarget(targetId, port);
+    logger.info(`🗑️ Target removido: ${targetId} de ${tg.TargetGroupName}`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return target;
+  }
+
+  describeTargetHealth(tgArn) {
+    const tg = this.getTargetGroup(tgArn);
+    return {
+      TargetGroupArn: tgArn,
+      HealthDescriptions: tg.Targets.map(t => ({
+        TargetId: t.TargetId,
+        Port: t.Port,
+        HealthState: t.HealthState,
+        HealthReason: t.HealthReason
+      }))
+    };
+  }
+
+  // ========== Listener Operations ==========
+
+  addListener(albArn, protocol = 'HTTP', port = 80, tgArn = null) {
+    const alb = this.getLoadBalancer(albArn);
+
+    if (tgArn) {
+      this.getTargetGroup(tgArn); // Validar que o TG existe
+    }
+
+    const listener = alb.addListener(protocol, port, tgArn);
+    logger.info(`✅ Listener adicionado: ${protocol}:${port} → ${tgArn}`);
+    // ✅ Persistir mudanças
+    this.persistData();
+    return listener;
+  }
+
+  // ========== Load Balancing Logic ==========
+
+  routeRequest(albArn, path = '/') {
+    const alb = this.getLoadBalancer(albArn);
+
+    // Se não há target groups, retornar erro
+    if (alb.TargetGroups.length === 0) {
+      return null;
+    }
+
+    // Usar o primeiro target group por padrão
+    const tg = alb.TargetGroups[0];
+    const nextTarget = tg.getNextTarget();
+
+    return nextTarget
+      ? {
+          TargetId: nextTarget.TargetId,
+          Port: nextTarget.Port,
+          TargetGroupArn: tg.TargetGroupArn
+        }
+      : null;
+  }
+
+  // ========== Utility ==========
+
+  getAllResources() {
+    return {
+      loadBalancers: Array.from(this.loadBalancers.values()),
+      targetGroups: Array.from(this.targetGroups.values())
+    };
+  }
+}
+
+module.exports = ALBSimulator;

package/src/services/apigateway/index.js

@@ -38,6 +38,28 @@ class APIGatewayService {
   injectDependencies(server) {
     const ct = server.getService('cloudtrail');
     if (ct?.simulator) this.simulator.audit.setTrail(ct.simulator);
+
+    const lambda = server.getService('lambda');
+    if (lambda) {
+      this.lambdaService = lambda;
+      if (this.simulator) this.simulator.setLambdaService(lambda);
+      if (this.server) this.server.lambdaService = lambda;
+    }
+    const sqs = server.getService('sqs');
+    if (sqs) {
+      if (this.simulator) this.simulator.setSqsService(sqs);
+      if (this.server) this.server.sqsService = sqs;
+    }
+    const sns = server.getService('sns');
+    if (sns) {
+      if (this.simulator) this.simulator.setSnsService(sns);
+      if (this.server) this.server.snsService = sns;
+    }
+    const eb = server.getService('eventbridge');
+    if (eb) {
+      if (this.simulator) this.simulator.setEventbridgeService(eb);
+      if (this.server) this.server.eventbridgeService = eb;
+    }
   }
 
   async start() {

package/src/services/apigateway/server.js

@@ -1,3 +1,4 @@
+const { setupServiceMiddleware } = require('../../middleware');
 /**
  * API Gateway Server - Servidor HTTP para API Gateway
  */
@@ -8,6 +9,8 @@ const logger = require('../../utils/logger');
 
 class APIGatewayServer {
   constructor(port, config) {
+    this.organizationsService = null;
+    this.stsService = null;
     this.port = port;
     this.config = config;
     this.app = express();
@@ -68,50 +71,159 @@ class APIGatewayServer {
       const cognitoAuthorizer = this._buildCognitoAuthorizer(api.authorizer);
 
       for (const endpoint of (api.endpoints || [])) {
-        const { path, method, lambdaName, integrationType, authorizerRequired } = endpoint;
+        const { path, method, lambdaName, integrationType, authorizerRequired, queueArn, queueUrl, eventBusName, topicArn } = endpoint;
         if (!path || !method) continue;
 
         const expressPath = path.replace(/\{([^}]+)\}/g, ':$1');
         const httpMethod = method.toLowerCase();
 
-        logger.debug(`📡 Registrando rota: ${method} ${path} -> ${lambdaName}`);
+        const intType = (integrationType || '').toLowerCase();
+        logger.debug(`📡 Registrando rota: ${method} ${path} -> ${intType || 'lambda'} (${lambdaName || queueArn || topicArn || eventBusName || 'n/a'})`);
 
-        const handler = async (req, res) => {
-          try {
-            const lambdaService = this.lambdaService;
-            if (!lambdaService) {
-              return res.status(500).json({ error: 'Lambda service not available' });
+        let handler;
+        if (intType === 'sqs' || queueArn || queueUrl) {
+          handler = async (req, res) => {
+            try {
+              const sqsService = this.sqsService;
+              if (!sqsService) {
+                return res.status(500).json({ error: 'SQS service not available' });
+              }
+              const sqsSim = sqsService.simulator;
+              let resolvedQueueUrl = queueUrl;
+              if (!resolvedQueueUrl && queueArn) {
+                const nameMatch = String(queueArn).match(/:([^:]+)$/);
+                if (nameMatch) {
+                  const q = sqsSim.queues.get(nameMatch[1]);
+                  resolvedQueueUrl = q && q.url;
+                }
+              }
+              const bodyContent = req.body ? (typeof req.body === 'string' ? req.body : JSON.stringify(req.body)) : '';
+              const messageBody = req.body?.MessageBody || bodyContent;
+              if (!resolvedQueueUrl) {
+                return res.status(400).json({ __type: 'MissingParameter', message: 'QueueUrl or queueArn must be configured' });
+              }
+              const result = sqsSim.sendMessage({
+                QueueUrl: resolvedQueueUrl,
+                MessageBody: messageBody,
+                DelaySeconds: req.body?.DelaySeconds,
+                MessageAttributes: req.body?.MessageAttributes
+              });
+              if (result.error) return res.status(result.status || 400).json(result.error);
+              res.status(200).json({
+                SendMessageResponse: {
+                  SendMessageResult: { MessageId: result.messageId, MD5OfMessageBody: result.md5 },
+                  ResponseMetadata: { RequestId: Math.random().toString(36).slice(2) }
+                }
+              });
+            } catch (err) {
+              logger.error('SQS send error:', err);
+              res.status(500).json({ error: err.message });
+            }
+          };
+        } else if (intType === 'eventbridge' || intType === 'events' || eventBusName) {
+          handler = async (req, res) => {
+            try {
+              const ebService = this.eventbridgeService;
+              if (!ebService) {
+                return res.status(500).json({ error: 'EventBridge service not available' });
+              }
+              const ebSim = ebService.simulator;
+              const entries = req.body?.Entries || [{
+                Source: req.body?.Source || 'aws.apigateway',
+                DetailType: req.body?.DetailType || 'API Gateway Request',
+                Detail: JSON.stringify(req.body?.Detail || req.body || {}),
+                EventBusName: eventBusName || req.body?.EventBusName || 'default',
+                Time: new Date().toISOString(),
+                Resources: []
+              }];
+              const norm = entries.map(e => ({
+                Time: e.Time || new Date().toISOString(),
+                Source: e.Source || 'aws.apigateway',
+                Resources: e.Resources || [],
+                DetailType: e.DetailType || 'API Gateway Request',
+                Detail: typeof e.Detail === 'string' ? e.Detail : JSON.stringify(e.Detail || {}),
+                EventBusName: eventBusName || e.EventBusName || 'default',
+                TraceHeader: e.TraceHeader
+              }));
+              const result = await ebSim.putEvents({ Entries: norm });
+              res.status(200).json({
+                Entries: (result.Entries || []).map(e => ({
+                  EventId: e.EventId || Math.random().toString(36).slice(2),
+                  ErrorCode: e.ErrorCode,
+                  ErrorMessage: e.ErrorMessage
+                })),
+                FailedEntryCount: result.FailedEntryCount || 0
+              });
+            } catch (err) {
+              logger.error('EventBridge putEvents error:', err);
+              res.status(500).json({ error: err.message });
             }
+          };
+        } else if (intType === 'sns' || topicArn) {
+          handler = async (req, res) => {
+            try {
+              const snsService = this.snsService;
+              if (!snsService) {
+                return res.status(500).json({ error: 'SNS service not available' });
+              }
+              const snsSim = snsService.simulator;
+              const message = req.body?.Message || (req.body ? (typeof req.body === 'string' ? req.body : JSON.stringify(req.body)) : '');
+              const result = await snsSim.publish({
+                TopicArn: topicArn || req.body?.TopicArn,
+                TargetArn: req.body?.TargetArn,
+                Message: message,
+                Subject: req.body?.Subject,
+                MessageAttributes: req.body?.MessageAttributes
+              });
+              res.status(200).json({
+                PublishResponse: {
+                  PublishResult: { MessageId: result.messageId || Math.random().toString(36).slice(2) },
+                  ResponseMetadata: { RequestId: Math.random().toString(36).slice(2) }
+                }
+              });
+            } catch (err) {
+              logger.error('SNS publish error:', err);
+              res.status(500).json({ error: err.message });
+            }
+          };
+        } else {
+          handler = async (req, res) => {
+            try {
+              const lambdaService = this.lambdaService;
+              if (!lambdaService) {
+                return res.status(500).json({ error: 'Lambda service not available' });
+              }
 
-            const event = {
-              httpMethod: req.method,
-              path: req.path,
-              headers: req.headers,
-              queryStringParameters: Object.keys(req.query).length ? req.query : null,
-              pathParameters: Object.keys(req.params).length ? req.params : null,
-              body: req.body ? JSON.stringify(req.body) : null,
-              isBase64Encoded: false,
-              requestContext: {
+              const event = {
+                httpMethod: req.method,
                 path: req.path,
-                stage: 'local',
-                requestId: Math.random().toString(36).substring(7),
-                identity: { sourceIp: req.ip },
-                authorizer: req.cognitoAuthorizer || null
-              }
-            };
-
-            const result = await lambdaService.simulator.invoke(lambdaName, event);
-            const payload = result.Payload || {};
-            const statusCode = payload.statusCode || 200;
-            const headers = payload.headers || { 'Content-Type': 'application/json' };
-            const body = payload.body;
-
-            res.status(statusCode).set(headers).send(body);
-          } catch (err) {
-            logger.error(`Lambda invoke error (${lambdaName}):`, err);
-            res.status(500).json({ error: err.message });
-          }
-        };
+                headers: req.headers,
+                queryStringParameters: Object.keys(req.query).length ? req.query : null,
+                pathParameters: Object.keys(req.params).length ? req.params : null,
+                body: req.body ? JSON.stringify(req.body) : null,
+                isBase64Encoded: false,
+                requestContext: {
+                  path: req.path,
+                  stage: 'local',
+                  requestId: Math.random().toString(36).substring(7),
+                  identity: { sourceIp: req.ip },
+                  authorizer: req.cognitoAuthorizer || null
+                }
+              };
+
+              const result = await lambdaService.simulator.invoke(lambdaName, event);
+              const payload = result.Payload || {};
+              const statusCode = payload.statusCode || 200;
+              const headers = payload.headers || { 'Content-Type': 'application/json' };
+              const body = payload.body;
+
+              res.status(statusCode).set(headers).send(body);
+            } catch (err) {
+              logger.error(`Lambda invoke error (${lambdaName}):`, err);
+              res.status(500).json({ error: err.message });
+            }
+          };
+        }
 
         const middlewares = [];
         if (authorizerRequired && cognitoAuthorizer) {
@@ -434,6 +546,106 @@ class APIGatewayServer {
       }
     });
 
+    // Models
+    this.app.post('/restapis/:apiId/models', (req, res) => {
+      try {
+        const result = this.simulator.createModel({ ...req.body, restApiId: req.params.apiId });
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    this.app.get('/restapis/:apiId/models', (req, res) => {
+      try {
+        const result = this.simulator.getModels({ restApiId: req.params.apiId });
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    this.app.get('/restapis/:apiId/models/:modelName', (req, res) => {
+      try {
+        const result = this.simulator.getModel({
+          restApiId: req.params.apiId,
+          modelName: req.params.modelName,
+          flatten: req.query.flatten
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    this.app.delete('/restapis/:apiId/models/:modelName', (req, res) => {
+      try {
+        const result = this.simulator.deleteModel({
+          restApiId: req.params.apiId,
+          modelName: req.params.modelName
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    // Request Validators
+    this.app.post('/restapis/:apiId/requestvalidators', (req, res) => {
+      try {
+        const result = this.simulator.createRequestValidator({ ...req.body, restApiId: req.params.apiId });
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    this.app.get('/restapis/:apiId/requestvalidators', (req, res) => {
+      try {
+        const result = this.simulator.getRequestValidators({ restApiId: req.params.apiId });
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    this.app.get('/restapis/:apiId/requestvalidators/:requestValidatorId', (req, res) => {
+      try {
+        const result = this.simulator.getRequestValidator({
+          restApiId: req.params.apiId,
+          requestValidatorId: req.params.requestValidatorId
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
+    this.app.patch('/restapis/:apiId/requestvalidators/:requestValidatorId', (req, res) => {
+      try {
+        const result = this.simulator.updateRequestValidator({
+          ...req.body,
+          restApiId: req.params.apiId,
+          requestValidatorId: req.params.requestValidatorId
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    this.app.delete('/restapis/:apiId/requestvalidators/:requestValidatorId', (req, res) => {
+      try {
+        const result = this.simulator.deleteRequestValidator({
+          restApiId: req.params.apiId,
+          requestValidatorId: req.params.requestValidatorId
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(404).json({ error: error.message });
+      }
+    });
+
     // HTTP APIs
     this.app.post('/httpapis', (req, res) => {
       try {