@gugananuvem/aws-local-simulator 1.0.34 → 1.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.34",
+  "version": "1.0.35",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -10,7 +10,6 @@
     "start": "node bin/aws-local-simulator.js start"
   },
   "dependencies": {
-    "better-sqlite3": "^11.0.0",
     "@aws-sdk/client-api-gateway": "^3.0.0",
     "@aws-sdk/client-cognito-identity-provider": "^3.0.0",
     "@aws-sdk/client-dynamodb": "^3.0.0",
@@ -19,6 +18,7 @@
     "@aws-sdk/client-s3": "^3.0.0",
     "@aws-sdk/client-sqs": "^3.0.0",
     "@aws-sdk/lib-dynamodb": "^3.0.0",
+    "better-sqlite3": "11.10.0",
     "child_process": "1.0.2",
     "cors": "^2.8.5",
     "crypto": "1.0.1",
@@ -67,6 +67,6 @@
   "publishConfig": {
     "directory": "dist"
   },
-  "buildDate": "2026-06-23T12:54:20.022Z",
+  "buildDate": "2026-06-26T03:40:01.988Z",
   "published": true
 }

package/src/services/lambda/handler-loader.js

@@ -146,9 +146,25 @@ class HandlerLoader {
    * Recarrega um handler (útil para hot reload)
    */
   static async reload(handlerPath, type = 'auto') {
-    // Limpa cache
-    const fullPath = path.resolve(process.cwd(), handlerPath);
-    delete require.cache[require.resolve(fullPath)];
+    // Resolve path: try cwd first, then data dir (same logic as load())
+    let fullPath = path.resolve(process.cwd(), handlerPath);
+
+    if (!fs.existsSync(fullPath)) {
+      const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+      if (dataDir) {
+        const dataPath = path.resolve(dataDir, 'lambda', handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          fullPath = dataPath;
+        }
+      }
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Handler não encontrado: ${fullPath}`);
+    }
+
+    // Limpa cache do require
+    delete require.cache[fullPath];
     
     // Recarrega
     return this.load(handlerPath, type);
@@ -158,7 +174,20 @@ class HandlerLoader {
    * Valida se um caminho de handler é válido
    */
   static isValid(handlerPath) {
-    const fullPath = path.resolve(process.cwd(), handlerPath);
+    // Tenta resolver de cwd primeiro
+    let fullPath = path.resolve(process.cwd(), handlerPath);
+    
+    if (!fs.existsSync(fullPath)) {
+      // Tenta resolver do data dir
+      const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+      if (dataDir) {
+        const dataPath = path.resolve(dataDir, 'lambda', handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          return true;
+        }
+      }
+    }
+    
     return fs.existsSync(fullPath);
   }
   
@@ -166,7 +195,23 @@ class HandlerLoader {
    * Retorna informações sobre o handler
    */
   static async getInfo(handlerPath) {
-    const fullPath = path.resolve(process.cwd(), handlerPath);
+    // Resolve path: try cwd first, then data dir (same logic as load())
+    let fullPath = path.resolve(process.cwd(), handlerPath);
+
+    if (!fs.existsSync(fullPath)) {
+      const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+      if (dataDir) {
+        const dataPath = path.resolve(dataDir, 'lambda', handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          fullPath = dataPath;
+        }
+      }
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Handler não encontrado: ${fullPath}`);
+    }
+
     const type = this.detectType(fullPath);
     const stats = fs.statSync(fullPath);
     

package/src/services/lambda/server.js

@@ -18,6 +18,7 @@ class LambdaServer {
   }
 
   setupMiddlewares() {
+    this.app.use(express.json()); // Adiciona suporte para JSON
     this.app.use(express.urlencoded({ extended: true }));
     this.app.use(cors());
     
@@ -91,20 +92,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 +106,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 +127,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);
@@ -222,6 +234,7 @@ class LambdaSimulator {
 
       return {
         name: l.name,
+        runtime: l.runtime,
         handlerName: l.handlerName,
         handlerPath: l.handlerPath,
         type: l.type,
@@ -297,25 +310,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);