@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/lambda/server.js

@@ -1,3 +1,4 @@
+const { setupServiceMiddleware } = require('../../middleware');
 /**
  * Lambda Server - Servidor HTTP para Lambda (API Gateway style)
  */
@@ -8,7 +9,9 @@ const LambdaSimulator = require('./simulator');
 const logger = require('../../utils/logger');
 
 class LambdaServer {
-  constructor(port, config) {
+  constructor(port, config) {
+    this.organizationsService = null;
+    this.stsService = null;
     this.port = port;
     this.config = config;
     this.app = express();
@@ -18,6 +21,7 @@ class LambdaServer {
   }
 
   setupMiddlewares() {
+    this.app.use(express.json()); // Adiciona suporte para JSON
     this.app.use(express.urlencoded({ extended: true }));
     this.app.use(cors());
     
@@ -41,6 +45,14 @@ class LambdaServer {
   }
 
   setupRoutes() {
+    // IAM enforcement (conditionally applied)
+    this.app.use((req, res, next) => {
+      if (this.iamMiddleware && !req.path.startsWith('/__admin') && !req.path.startsWith('/health')) {
+        return this.iamMiddleware(req, res, next);
+      }
+      next();
+    });
+
     // Health check
     this.app.get('/health', (req, res) => {
       res.json({ status: 'healthy', lambdas: this.simulator.getLambdasCount() });
@@ -91,20 +103,13 @@ class LambdaServer {
   }
 
   setupAdminRoutes() {
-    // Helper: parse Buffer body as JSON for admin routes
-    const parseJson = (req, res, next) => {
-      if (Buffer.isBuffer(req.body) && req.body.length > 0) {
-        try { req.body = JSON.parse(req.body.toString('utf8')); } catch { req.body = {}; }
-      }
-      next();
-    };
-
     this.app.get('/__admin/functions', (req, res) => {
       res.json(this.simulator.listLambdas());
     });
     
-    this.app.post('/__admin/functions', parseJson, async (req, res) => {
+    this.app.post('/__admin/functions', async (req, res) => {
       try {
+        logger.debug(`📥 POST /__admin/functions:`, req.body);
         const lambda = await this.simulator.createFunction(req.body);
         res.status(201).json(lambda);
       } catch (err) {
@@ -112,8 +117,9 @@ class LambdaServer {
       }
     });
 
-    this.app.put('/__admin/functions/:name', parseJson, async (req, res) => {
+    this.app.put('/__admin/functions/:name', async (req, res) => {
       try {
+        logger.debug(`📥 PUT /__admin/functions/${req.params.name}:`, req.body);
         const lambda = await this.simulator.updateFunction(req.params.name, req.body);
         res.json(lambda);
       } catch (err) {
@@ -132,7 +138,7 @@ class LambdaServer {
       res.json({ message: 'Lambdas recarregadas', count: this.simulator.getLambdasCount() });
     });
 
-    this.app.post('/__admin/env', parseJson, (req, res) => {
+    this.app.post('/__admin/env', (req, res) => {
       const { key, value } = req.body;
       if (key && value !== undefined) {
         this.simulator.setEnvironmentVariable(key, value);

package/src/services/lambda/simulator.js

@@ -48,13 +48,24 @@ class LambdaSimulator {
 
   async registerLambda(lambdaConfig) {
     try {
-      const { name, handler: handlerPath, type = "auto" } = lambdaConfig;
+      const { name, handler: handlerPath, type = "auto", runtime = "nodejs18.x" } = lambdaConfig;
 
       if (!name) {
         logger.warn(`Lambda sem nome ignorada: ${JSON.stringify(lambdaConfig)}`);
         return;
       }
 
+      // Resolve the handler path to absolute path
+      let resolvedHandlerPath = path.resolve(process.cwd(), handlerPath);
+      
+      // Se não existir no cwd, tenta no data dir
+      if (!fs.existsSync(resolvedHandlerPath)) {
+        const dataPath = path.resolve(this.dataDir, handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          resolvedHandlerPath = dataPath;
+        }
+      }
+
       // Merge: global env as base, lambda-specific env overrides
       const env = {
         ...(this.globalEnv || {}),
@@ -76,8 +87,9 @@ class LambdaSimulator {
       if (handler != undefined) {
         this.lambdas.set(name, {
           name,
+          runtime,
           handler,
-          handlerPath,
+          handlerPath: resolvedHandlerPath,
           handlerName: handler.name || "anonymous",
           env,
           timeout,
@@ -87,7 +99,7 @@ class LambdaSimulator {
           registeredAt: new Date().toISOString(),
         });
       }
-      logger.debug(`✅ Lambda registrada: ${name} -> ${handlerPath}`);
+      logger.debug(`✅ Lambda registrada: ${name} -> ${resolvedHandlerPath}`);
     } catch (error) {     
       if (error.message.indexOf("Handler não encontrado") == -1){
         logger.error(`Erro ao registrar Lambda ${lambdaConfig.name}:`, error);
@@ -129,6 +141,10 @@ class LambdaSimulator {
     return { StatusCode: result.statusCode || 200, Payload: result };
   }
 
+  async invokeFunction(functionName, event) {
+    return this.invoke(functionName, event, "Event");
+  }
+
   async executeHandler(lambda, functionName, event) {
     const requestId = Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10);
     const capturedLogs = [];
@@ -222,6 +238,7 @@ class LambdaSimulator {
 
       return {
         name: l.name,
+        runtime: l.runtime,
         handlerName: l.handlerName,
         handlerPath: l.handlerPath,
         type: l.type,
@@ -297,25 +314,64 @@ class LambdaSimulator {
     const lambda = this.lambdas.get(name);
     if (!lambda) throw new Error(`Function not found: ${name}`);
 
-    const { code, runtime, handler, timeout, memorySize, environment } = lambdaConfig;
+    // Normaliza 'environment' para 'env' se necessário
+    const config = {
+      ...lambdaConfig,
+      env: lambdaConfig.environment || lambdaConfig.env
+    };
+    delete config.environment; // Remove para evitar confusão
+
+    const { code, runtime, handler, timeout, memorySize, env } = config;
+
+    logger.debug(`📝 Updating function ${name}:`, { 
+      hasCode: !!code, 
+      code: code ? `(${code.length} chars)` : 'NULL/UNDEFINED',
+      codeLength: code?.length,
+      runtime, 
+      timeout, 
+      memorySize,
+      handlerPath: lambda.handlerPath,
+      configKeys: Object.keys(config)
+    });
 
     // Se houver código novo, sobrescreve o arquivo
-    if (code !== undefined) {
-      fs.writeFileSync(lambda.handlerPath, code);
+    if (code !== undefined && code !== null && code.trim() !== '') {
+      logger.debug(`💾 Escrevendo código no arquivo: ${lambda.handlerPath}`);
+      try {
+        fs.writeFileSync(lambda.handlerPath, code, 'utf8');
+        logger.debug(`✅ Arquivo atualizado com sucesso`);
+      } catch (err) {
+        logger.error(`❌ Erro ao escrever arquivo:`, err);
+        throw err;
+      }
+
+      // Reload the handler from the updated file
+      try {
+        const newHandler = await HandlerLoader.reload(lambda.handlerPath, lambda.type);
+        lambda.handler = newHandler;
+        lambda.handlerName = newHandler.name || "anonymous";
+        
+        // Update code size
+        try {
+          const info = await HandlerLoader.getInfo(lambda.handlerPath);
+          lambda.codeSize = info.size;
+        } catch (err) {
+          // Ignore size errors
+        }
+      } catch (error) {
+        logger.error(`❌ Erro ao recarregar Lambda ${name}:`, error);
+        throw error;
+      }
+    } else {
+      logger.warn(`⚠️ Nenhum código fornecido para atualização. code=${JSON.stringify(code)}`);
     }
 
-    // Atualiza a configuração
-    const updatedConfig = {
-      name,
-      handler: lambda.handlerPath,
-      runtime: runtime || lambda.runtime,
-      timeout: timeout || lambda.timeout,
-      memorySize: memorySize || lambda.memorySize,
-      env: environment || lambda.env,
-      type: lambda.type
-    };
+    // Atualiza outras configurações
+    if (runtime !== undefined) lambda.runtime = runtime;
+    if (timeout !== undefined) lambda.timeout = timeout;
+    if (memorySize !== undefined) lambda.memorySize = memorySize;
+    if (env !== undefined) lambda.env = env;
 
-    await this.registerLambda(updatedConfig);
     this.persistLambdas();
 
     return this.lambdas.get(name);

package/src/services/opensearch/index.js

@@ -0,0 +1,105 @@
+/**
+ * OpenSearch Service - Ponto de entrada
+ */
+
+const OpenSearchServer = require('./server');
+const OpenSearchSimulator = require('./simulator');
+
+class OpenSearchService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'opensearch';
+    this.port = config.ports.opensearch || 9200;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando OpenSearch Service na porta ${this.port}...`);
+
+    this.simulator = new OpenSearchSimulator(this.config);
+    await this.simulator.initialize();
+
+    this.server = new OpenSearchServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+
+    await this.server.initialize();
+
+    logger.debug('OpenSearch Service inicializado');
+  }
+
+  injectDependencies(server) {
+    // Aqui você pode injetar dependências de outros serviços se necessário
+  }
+
+  async start() {
+    const logger = require('../../utils/logger');
+
+    if (this.isRunning) {
+      logger.warn('OpenSearch Service já está em execução');
+      return;
+    }
+
+    try {
+      await this.server.start();
+      this.isRunning = true;
+      logger.info('OpenSearch Service iniciado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao iniciar OpenSearch Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async stop() {
+    const logger = require('../../utils/logger');
+
+    if (!this.isRunning) {
+      logger.warn('OpenSearch Service não está em execução');
+      return;
+    }
+
+    try {
+      await this.server.stop();
+      this.isRunning = false;
+      logger.info('OpenSearch Service parado com sucesso');
+    } catch (error) {
+      logger.error(`Erro ao parar OpenSearch Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  async reset() {
+    const logger = require('../../utils/logger');
+    try {
+      await this.simulator.reset();
+      logger.info('OpenSearch Service resetado');
+    } catch (error) {
+      logger.error(`Erro ao resetar OpenSearch Service: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getStatus() {
+    const stats = this.simulator?.getClusterStats() || { indices: 0, docs: 0, size_mb: 0 };
+
+    return {
+      name: this.name,
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      resources: {
+        indicesCount: stats.indices,
+        docsCount: stats.docs,
+        sizeMb: stats.size_mb
+      }
+    };
+  }
+}
+
+module.exports = OpenSearchService;

package/src/services/opensearch/models/document.js

@@ -0,0 +1,115 @@
+/**
+ * OpenSearch Document Model - Equivalente ao Item no DynamoDB
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Document {
+  constructor(data = {}, config = {}) {
+    this._id = config._id || uuidv4();
+    this._type = config._type || '_doc';
+    this._index = config._index || null;
+    this._version = config._version || 1;
+    this._seq_no = config._seq_no || 0;
+    this._primary_term = config._primary_term || 1;
+    this._score = config._score || null;
+
+    // Metadados
+    this._createdAt = config._createdAt || new Date().toISOString();
+    this._updatedAt = config._updatedAt || new Date().toISOString();
+
+    // Source - dados do documento
+    this._source = data;
+
+    // Highlights - para busca
+    this.highlight = {};
+  }
+
+  /**
+   * Atualiza documento
+   */
+  update(data = {}) {
+    this._source = { ...this._source, ...data };
+    this._version++;
+    this._updatedAt = new Date().toISOString();
+  }
+
+  /**
+   * Incrementa version
+   */
+  incrementVersion() {
+    this._version++;
+    this._updatedAt = new Date().toISOString();
+  }
+
+  /**
+   * Retorna documento em formato Elasticsearch
+   */
+  toJSON() {
+    return {
+      _id: this._id,
+      _type: this._type,
+      _index: this._index,
+      _version: this._version,
+      _seq_no: this._seq_no,
+      _primary_term: this._primary_term,
+      _score: this._score,
+      _source: this._source,
+      highlight: Object.keys(this.highlight).length > 0 ? this.highlight : undefined
+    };
+  }
+
+  /**
+   * Retorna apenas _source
+   */
+  getSource() {
+    return this._source;
+  }
+
+  /**
+   * Retorna tamanho em bytes (aproximado)
+   */
+  getSize() {
+    return JSON.stringify(this._source).length;
+  }
+
+  /**
+   * Verifica se documento match em busca simples
+   */
+  matchesQuery(query = {}) {
+    if (Object.keys(query).length === 0) return true;
+
+    for (const [key, value] of Object.entries(query)) {
+      if (key === '_id' && this._id !== value) return false;
+      if (key === '_type' && this._type !== value) return false;
+      if (!(key in this._source)) return false;
+
+      const fieldValue = this._source[key];
+      if (typeof fieldValue === 'string') {
+        if (!fieldValue.toLowerCase().includes(String(value).toLowerCase())) return false;
+      } else if (fieldValue !== value) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Busca full-text simples
+   */
+  matchesFullText(text = '') {
+    if (!text) return true;
+
+    const searchText = text.toLowerCase();
+    for (const value of Object.values(this._source)) {
+      if (typeof value === 'string' && value.toLowerCase().includes(searchText)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
+
+module.exports = Document;

package/src/services/opensearch/models/index.js

@@ -0,0 +1,73 @@
+/**
+ * OpenSearch Index Model - Equivalente à Table no DynamoDB
+ */
+
+const { v4: uuidv4 } = require('uuid');
+
+class Index {
+  constructor(name, config = {}) {
+    this.name = name;
+    this.settings = {
+      number_of_shards: config.number_of_shards || 1,
+      number_of_replicas: config.number_of_replicas || 1,
+      analysis: config.analysis || {
+        analyzer: {
+          default: {
+            type: 'standard'
+          }
+        }
+      }
+    };
+
+    // Mappings - Define tipos de campos
+    this.mappings = {
+      properties: config.properties || {
+        _id: { type: 'keyword' },
+        _type: { type: 'keyword' },
+        _source: { type: 'text' }
+      }
+    };
+
+    this.aliases = config.aliases || {};
+    this.createdAt = new Date().toISOString();
+    this.status = 'open';
+    this.docsCount = 0;
+    this.storeSize = 0;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      settings: this.settings,
+      mappings: this.mappings,
+      aliases: this.aliases,
+      status: this.status,
+      createdAt: this.createdAt,
+      docsCount: this.docsCount,
+      storeSize: this.storeSize
+    };
+  }
+
+  /**
+   * Adiciona documento - incrementa contador
+   */
+  addDocument() {
+    this.docsCount++;
+  }
+
+  /**
+   * Remove documento - decrementa contador
+   */
+  removeDocument() {
+    if (this.docsCount > 0) this.docsCount--;
+  }
+
+  /**
+   * Atualiza tamanho do índice
+   */
+  updateSize(totalSize) {
+    this.storeSize = totalSize;
+  }
+}
+
+module.exports = Index;