@gugananuvem/aws-local-simulator 1.0.12 → 1.0.15

package/src/services/lambda/server.js

@@ -1,146 +1,146 @@
-/**
- * Lambda Server - Servidor HTTP para Lambda (API Gateway style)
- */
-
-const express = require('express');
-const cors = require('cors');
-const LambdaSimulator = require('./simulator');
-const logger = require('../../utils/logger');
-
-class LambdaServer {
-  constructor(port, config) {
-    this.port = port;
-    this.config = config;
-    this.app = express();
-    this.simulator = null;
-    this.server = null;
-    this.setupMiddlewares();
-  }
-
-  setupMiddlewares() {
-    this.app.use(express.json({ limit: '10mb' }));
-    this.app.use(express.urlencoded({ extended: true }));
-    this.app.use(cors());
-    
-    // Logging de requisições
-    if (logger.currentLogLevel === 'verboso') {
-      this.app.use((req, res, next) => {
-        const start = Date.now();
-        res.on('finish', () => {
-          const duration = Date.now() - start;
-          logger.verboso(`Lambda: ${req.method} ${req.path} - ${duration}ms`);
-        });
-        next();
-      });
-    }
-  }
-
-  async initialize() {
-    this.simulator = new LambdaSimulator(this.config);
-    await this.simulator.initialize();
-    this.setupRoutes();
-  }
-
-  setupRoutes() {
-    // Health check
-    this.app.get('/health', (req, res) => {
-      res.json({ status: 'healthy', lambdas: this.simulator.getLambdasCount() });
-    });
-
-    // AWS Lambda Invoke API: POST /2015-03-31/functions/{functionName}/invocations
-    this.app.post('/2015-03-31/functions/:functionName/invocations', async (req, res) => {
-      const { functionName } = req.params;
-      const invocationType = req.headers['x-amz-invocation-type'] || 'RequestResponse';
-      const event = req.body || {};
-
-      logger.debug(`Lambda invoke: ${functionName} (${invocationType})`);
-
-      try {
-        const result = await this.simulator.invoke(functionName, event, invocationType);
-
-        if (invocationType === 'Event') {
-          return res.status(202).send();
-        }
-
-        res.status(result.StatusCode || 200).json(result.Payload);
-      } catch (err) {
-        if (err.message && err.message.includes('Function not found')) {
-          return res.status(404).json({ __type: 'ResourceNotFoundException', message: err.message });
-        }
-        logger.error('Lambda invoke error:', err);
-        res.status(500).json({ __type: 'ServiceException', message: err.message });
-      }
-    });
-
-    // Admin endpoints
-    this.setupAdminRoutes();
-  }
-
-  setupAdminRoutes() {
-    this.app.get('/__admin/functions', (req, res) => {
-      res.json(this.simulator.listLambdas());
-    });
-
-    this.app.post('/__admin/reload', async (req, res) => {
-      await this.simulator.reloadLambdas();
-      res.json({ message: 'Lambdas recarregadas', count: this.simulator.getLambdasCount() });
-    });
-
-    this.app.post('/__admin/env', (req, res) => {
-      const { key, value } = req.body;
-      if (key && value !== undefined) {
-        this.simulator.setEnvironmentVariable(key, value);
-        res.json({ message: `Environment variable ${key} set` });
-      } else {
-        res.status(400).json({ error: 'Missing key or value' });
-      }
-    });
-
-    this.app.get('/__admin/env', (req, res) => {
-      res.json(this.simulator.getEnvironmentVariables());
-    });
-
-    this.app.get('/__admin/stats', (req, res) => {
-      res.json(this.simulator.getStats());
-    });
-  }
-
-  start() {
-    return new Promise((resolve) => {
-      this.server = this.app.listen(this.port, () => {
-        logger.info(`🚀 Lambda API rodando em http://localhost:${this.port}`);
-        this.printRoutes();
-        resolve();
-      });
-    });
-  }
-
-  printRoutes() {
-    logger.info('\n📚 Lambdas registradas:');
-    const lambdas = this.simulator.listLambdas();
-    for (const lambda of lambdas) {
-      logger.info(`   ${lambda.name.padEnd(30)} -> ${lambda.handlerName || 'anonymous'}`);
-    }
-  }
-
-  stop() {
-    return new Promise((resolve) => {
-      if (this.server) {
-        this.server.close(() => resolve());
-      } else {
-        resolve();
-      }
-    });
-  }
-
-  getStatus() {
-    return {
-      running: !!this.server,
-      port: this.port,
-      endpoint: `http://localhost:${this.port}`,
-      lambdasCount: this.simulator?.getLambdasCount() || 0
-    };
-  }
-}
-
+/**
+ * Lambda Server - Servidor HTTP para Lambda (API Gateway style)
+ */
+
+const express = require('express');
+const cors = require('cors');
+const LambdaSimulator = require('./simulator');
+const logger = require('../../utils/logger');
+
+class LambdaServer {
+  constructor(port, config) {
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.simulator = null;
+    this.server = null;
+    this.setupMiddlewares();
+  }
+
+  setupMiddlewares() {
+    this.app.use(express.json({ limit: '10mb' }));
+    this.app.use(express.urlencoded({ extended: true }));
+    this.app.use(cors());
+    
+    // Logging de requisições
+    if (logger.currentLogLevel === 'verboso') {
+      this.app.use((req, res, next) => {
+        const start = Date.now();
+        res.on('finish', () => {
+          const duration = Date.now() - start;
+          logger.verboso(`Lambda: ${req.method} ${req.path} - ${duration}ms`);
+        });
+        next();
+      });
+    }
+  }
+
+  async initialize() {
+    this.simulator = new LambdaSimulator(this.config);
+    await this.simulator.initialize();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // Health check
+    this.app.get('/health', (req, res) => {
+      res.json({ status: 'healthy', lambdas: this.simulator.getLambdasCount() });
+    });
+
+    // AWS Lambda Invoke API: POST /2015-03-31/functions/{functionName}/invocations
+    this.app.post('/2015-03-31/functions/:functionName/invocations', async (req, res) => {
+      const { functionName } = req.params;
+      const invocationType = req.headers['x-amz-invocation-type'] || 'RequestResponse';
+      const event = req.body || {};
+
+      logger.debug(`Lambda invoke: ${functionName} (${invocationType})`);
+
+      try {
+        const result = await this.simulator.invoke(functionName, event, invocationType);
+
+        if (invocationType === 'Event') {
+          return res.status(202).send();
+        }
+
+        res.status(result.StatusCode || 200).json(result.Payload);
+      } catch (err) {
+        if (err.message && err.message.includes('Function not found')) {
+          return res.status(404).json({ __type: 'ResourceNotFoundException', message: err.message });
+        }
+        logger.error('Lambda invoke error:', err);
+        res.status(500).json({ __type: 'ServiceException', message: err.message });
+      }
+    });
+
+    // Admin endpoints
+    this.setupAdminRoutes();
+  }
+
+  setupAdminRoutes() {
+    this.app.get('/__admin/functions', (req, res) => {
+      res.json(this.simulator.listLambdas());
+    });
+
+    this.app.post('/__admin/reload', async (req, res) => {
+      await this.simulator.reloadLambdas();
+      res.json({ message: 'Lambdas recarregadas', count: this.simulator.getLambdasCount() });
+    });
+
+    this.app.post('/__admin/env', (req, res) => {
+      const { key, value } = req.body;
+      if (key && value !== undefined) {
+        this.simulator.setEnvironmentVariable(key, value);
+        res.json({ message: `Environment variable ${key} set` });
+      } else {
+        res.status(400).json({ error: 'Missing key or value' });
+      }
+    });
+
+    this.app.get('/__admin/env', (req, res) => {
+      res.json(this.simulator.getEnvironmentVariables());
+    });
+
+    this.app.get('/__admin/stats', (req, res) => {
+      res.json(this.simulator.getStats());
+    });
+  }
+
+  start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`🚀 Lambda API rodando em http://localhost:${this.port}`);
+        this.printRoutes();
+        resolve();
+      });
+    });
+  }
+
+  printRoutes() {
+    logger.info('\n📚 Lambdas registradas:');
+    const lambdas = this.simulator.listLambdas();
+    for (const lambda of lambdas) {
+      logger.info(`   ${lambda.name.padEnd(30)} -> ${lambda.handlerName || 'anonymous'}`);
+    }
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  getStatus() {
+    return {
+      running: !!this.server,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      lambdasCount: this.simulator?.getLambdasCount() || 0
+    };
+  }
+}
+
 module.exports = LambdaServer;

package/src/services/lambda/simulator.js

@@ -1,172 +1,199 @@
-/**
- * Lambda Simulator - Simula execução de funções Lambda
- */
-
-const HandlerLoader = require('./handler-loader');
-const logger = require('../../utils/logger');
-
-class LambdaSimulator {
-  constructor(config) {
-    this.config = config;
-    this.lambdas = new Map(); // functionName -> { handler, env, config }
-    this.environment = { ...process.env };
-  }
-
-  async initialize() {
-    logger.debug('Inicializando Lambda Simulator...');
-
-    if (this.config.lambdas && this.config.lambdas.length > 0) {
-      for (const lambdaConfig of this.config.lambdas) {
-        await this.registerLambda(lambdaConfig);
-      }
-    }
-
-    logger.debug(`✅ ${this.lambdas.size} Lambdas registradas`);
-  }
-
-  async registerLambda(lambdaConfig) {
-    try {
-      const { name, handler: handlerPath, env = {}, type = 'auto' } = lambdaConfig;
-
-      if (!name) {
-        logger.warn(`Lambda sem nome ignorada: ${JSON.stringify(lambdaConfig)}`);
-        return;
-      }
-
-      const handler = await HandlerLoader.load(handlerPath, type);
-
-      this.lambdas.set(name, {
-        name,
-        handler,
-        handlerPath,
-        handlerName: handler.name || 'anonymous',
-        env,
-        type,
-        registeredAt: new Date().toISOString()
-      });
-
-      logger.debug(`✅ Lambda registrada: ${name} -> ${handlerPath}`);
-    } catch (error) {
-      logger.error(`❌ Erro ao registrar Lambda ${lambdaConfig.name}:`, error);
-      throw error;
-    }
-  }
-
-  async invoke(functionName, event, invocationType = 'RequestResponse') {
-    const lambda = this.lambdas.get(functionName);
-
-    if (!lambda) {
-      throw new Error(`Function not found: ${functionName}`);
-    }
-
-    this.applyEnvironment(lambda.env);
-    logger.debug(`🎯 Invocando Lambda: ${functionName}`);
-
-    if (invocationType === 'Event') {
-      this.executeHandler(lambda.handler, event).catch(err =>
-        logger.error(`❌ Async Lambda error (${functionName}):`, err)
-      );
-      return { StatusCode: 202 };
-    }
-
-    const result = await this.executeHandler(lambda.handler, event);
-    return { StatusCode: result.statusCode || 200, Payload: result };
-  }
-
-  async executeHandler(handler, event) {
-    try {
-      const context = this.createContext();
-      const result = await handler(event, context);
-      return result;
-    } catch (error) {
-      logger.error('❌ Erro no handler:', error);
-      return {
-        statusCode: 500,
-        body: JSON.stringify({ error: 'Internal Server Error', message: error.message })
-      };
-    }
-  }
-
-  createContext() {
-    return {
-      awsRequestId: Math.random().toString(36).substring(7),
-      functionName: 'local-lambda',
-      functionVersion: '$LATEST',
-      invokedFunctionArn: 'arn:aws:lambda:local:000000000000:function:local-lambda',
-      memoryLimitInMB: '1024',
-      logGroupName: '/aws/lambda/local-lambda',
-      logStreamName: 'local-stream',
-      getRemainingTimeInMillis: () => 30000,
-      callbackWaitsForEmptyEventLoop: true,
-      identity: null,
-      clientContext: null
-    };
-  }
-
-  applyEnvironment(env) {
-    for (const [key, value] of Object.entries(env)) {
-      process.env[key] = value;
-      this.environment[key] = value;
-    }
-  }
-
-  setEnvironmentVariable(key, value) {
-    process.env[key] = value;
-    this.environment[key] = value;
-  }
-
-  getEnvironmentVariables() {
-    return { ...this.environment };
-  }
-
-  listLambdas() {
-    return Array.from(this.lambdas.values()).map(l => ({
-      name: l.name,
-      handlerName: l.handlerName,
-      handlerPath: l.handlerPath,
-      type: l.type,
-      env: l.env,
-      registeredAt: l.registeredAt
-    }));
-  }
-
-  getLambda(name) {
-    return this.lambdas.get(name);
-  }
-
-  getLambdasCount() {
-    return this.lambdas.size;
-  }
-
-  async reloadLambdas() {
-    logger.info('🔄 Recarregando Lambdas...');
-
-    for (const [name, lambda] of this.lambdas.entries()) {
-      try {
-        const newHandler = await HandlerLoader.reload(lambda.handlerPath, lambda.type);
-        lambda.handler = newHandler;
-        lambda.handlerName = newHandler.name || 'anonymous';
-        logger.debug(`✅ Lambda recarregada: ${name}`);
-      } catch (error) {
-        logger.error(`❌ Erro ao recarregar Lambda ${name}:`, error);
-      }
-    }
-
-    logger.info(`✅ ${this.lambdas.size} Lambdas recarregadas`);
-  }
-
-  getStats() {
-    return {
-      totalLambdas: this.lambdas.size,
-      lambdas: this.listLambdas().map(l => ({ name: l.name, handler: l.handlerName }))
-    };
-  }
-
-  async reset() {
-    await this.reloadLambdas();
-    this.environment = { ...process.env };
-    logger.debug('Lambda: Estado resetado');
-  }
-}
-
-module.exports = LambdaSimulator;
+/**
+ * Lambda Simulator - Simula execução de funções Lambda
+ */
+
+const HandlerLoader = require("./handler-loader");
+const logger = require("../../utils/logger");
+const { CloudTrailAudit } = require("../../utils/cloudtrail-audit");
+
+class LambdaSimulator {
+  constructor(config) {
+    this.config = config;
+    this.lambdas = new Map(); // functionName -> { handler, env, config }
+    this.environment = { ...process.env };
+    this.audit = new CloudTrailAudit("lambda.amazonaws.com");
+  }
+
+  async initialize() {
+    logger.debug("Inicializando Lambda Simulator...");
+
+    // Build global lambda defaults from config.global
+    const globalDefaults = this.config.global || {};
+    this.globalEnv = globalDefaults.env || {};
+    this.globalTimeout = globalDefaults.timeout || null;
+    this.globalMemorySize = globalDefaults.memorySize || null;
+
+    if (this.config.lambdas && this.config.lambdas.length > 0) {
+      for (const lambdaConfig of this.config.lambdas) {
+        await this.registerLambda(lambdaConfig);
+      }
+    }
+
+    logger.debug(`✅ ${this.lambdas.size} Lambdas registradas`);
+  }
+
+  async registerLambda(lambdaConfig) {
+    try {
+      const { name, handler: handlerPath, type = "auto" } = lambdaConfig;
+
+      if (!name) {
+        logger.warn(`Lambda sem nome ignorada: ${JSON.stringify(lambdaConfig)}`);
+        return;
+      }
+
+      // Merge: global env as base, lambda-specific env overrides
+      const env = {
+        ...(this.globalEnv || {}),
+        ...(lambdaConfig.env || {}),
+      };
+
+      const timeout = lambdaConfig.timeout ?? this.globalTimeout ?? 30;
+      const memorySize = lambdaConfig.memorySize ?? this.globalMemorySize ?? 128;
+
+      const handler = await HandlerLoader.load(handlerPath, type);
+      if (handler != undefined) {
+        this.lambdas.set(name, {
+          name,
+          handler,
+          handlerPath,
+          handlerName: handler.name || "anonymous",
+          env,
+          timeout,
+          memorySize,
+          type,
+          registeredAt: new Date().toISOString(),
+        });
+      }
+      logger.debug(`✅ Lambda registrada: ${name} -> ${handlerPath}`);
+    } catch (error) {     
+      if (error.message.indexOf("Handler não encontrado") == -1){
+        logger.error(`Erro ao registrar Lambda ${lambdaConfig.name}:`, error);
+        throw error;
+      }else{
+        logger.error(`Erro ao registrar Lambda ${lambdaConfig.name}:`);
+      }
+    }
+  }
+
+  async invoke(functionName, event, invocationType = "RequestResponse") {
+    const lambda = this.lambdas.get(functionName);
+
+    if (!lambda) {
+      throw new Error(`Function not found: ${functionName}`);
+    }
+
+    this.applyEnvironment(lambda.env);
+    logger.debug(`🎯 Invocando Lambda: ${functionName}`);
+
+    if (invocationType === "Event") {
+      this.executeHandler(lambda.handler, event).catch((err) => logger.error(`❌ Async Lambda error (${functionName}):`, err));
+      return { StatusCode: 202 };
+    }
+
+    const result = await this.executeHandler(lambda.handler, event);
+    this.audit.record({
+      eventName: "Invoke",
+      readOnly: false,
+      resources: [{ ARN: `arn:aws:lambda:local:000000000000:function:${functionName}`, type: "AWS::Lambda::Function" }],
+      requestParameters: { functionName, invocationType },
+    });
+    return { StatusCode: result.statusCode || 200, Payload: result };
+  }
+
+  async executeHandler(handler, event) {
+    try {
+      const context = this.createContext();
+      const result = await handler(event, context);
+      return result;
+    } catch (error) {
+      logger.error("❌ Erro no handler:", error);
+      return {
+        statusCode: 500,
+        body: JSON.stringify({ error: "Internal Server Error", message: error.message }),
+      };
+    }
+  }
+
+  createContext() {
+    return {
+      awsRequestId: Math.random().toString(36).substring(7),
+      functionName: "local-lambda",
+      functionVersion: "$LATEST",
+      invokedFunctionArn: "arn:aws:lambda:local:000000000000:function:local-lambda",
+      memoryLimitInMB: "1024",
+      logGroupName: "/aws/lambda/local-lambda",
+      logStreamName: "local-stream",
+      getRemainingTimeInMillis: () => 30000,
+      callbackWaitsForEmptyEventLoop: true,
+      identity: null,
+      clientContext: null,
+    };
+  }
+
+  applyEnvironment(env) {
+    for (const [key, value] of Object.entries(env)) {
+      process.env[key] = value;
+      this.environment[key] = value;
+    }
+  }
+
+  setEnvironmentVariable(key, value) {
+    process.env[key] = value;
+    this.environment[key] = value;
+  }
+
+  getEnvironmentVariables() {
+    return { ...this.environment };
+  }
+
+  listLambdas() {
+    return Array.from(this.lambdas.values()).map((l) => ({
+      name: l.name,
+      handlerName: l.handlerName,
+      handlerPath: l.handlerPath,
+      type: l.type,
+      env: l.env,
+      registeredAt: l.registeredAt,
+    }));
+  }
+
+  getLambda(name) {
+    return this.lambdas.get(name);
+  }
+
+  getLambdasCount() {
+    return this.lambdas.size;
+  }
+
+  async reloadLambdas() {
+    logger.info("🔄 Recarregando Lambdas...");
+
+    for (const [name, lambda] of this.lambdas.entries()) {
+      try {
+        const newHandler = await HandlerLoader.reload(lambda.handlerPath, lambda.type);
+        lambda.handler = newHandler;
+        lambda.handlerName = newHandler.name || "anonymous";
+        logger.debug(`✅ Lambda recarregada: ${name}`);
+      } catch (error) {
+        logger.error(`❌ Erro ao recarregar Lambda ${name}:`, error);
+      }
+    }
+
+    logger.info(`✅ ${this.lambdas.size} Lambdas recarregadas`);
+  }
+
+  getStats() {
+    return {
+      totalLambdas: this.lambdas.size,
+      lambdas: this.listLambdas().map((l) => ({ name: l.name, handler: l.handlerName })),
+    };
+  }
+
+  async reset() {
+    await this.reloadLambdas();
+    this.environment = { ...process.env };
+    logger.debug("Lambda: Estado resetado");
+  }
+}
+
+module.exports = LambdaSimulator;