@gugananuvem/aws-local-simulator 1.0.0 → 1.0.1

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

@@ -0,0 +1,173 @@
+/**
+ * Handler Loader - Carrega handlers de Lambda em diferentes formatos
+ * Suporta: CommonJS, ES Modules, TypeScript (compilado)
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { pathToFileURL } = require('url');
+const logger = require('../../utils/logger');
+
+class HandlerLoader {
+  /**
+   * Carrega um handler de Lambda
+   * @param {string} handlerPath - Caminho para o arquivo do handler
+   * @param {string} type - Tipo do módulo: 'commonjs', 'module', 'auto'
+   * @returns {Promise<Function>} - Função handler
+   */
+  static async load(handlerPath, type = 'auto') {
+    const fullPath = path.resolve(process.cwd(), handlerPath);
+    
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Handler não encontrado: ${fullPath}`);
+    }
+    
+    logger.verboso(`Carregando handler: ${fullPath} (type: ${type})`);
+    
+    try {
+      let handler;
+      let resolvedType = type;
+      
+      // Detecta o tipo se for auto
+      if (type === 'auto') {
+        resolvedType = this.detectType(fullPath);
+      }
+      
+      // Carrega baseado no tipo
+      if (resolvedType === 'module' || fullPath.endsWith('.mjs')) {
+        // ES Module
+        const fileUrl = pathToFileURL(fullPath).href;
+        const module = await import(fileUrl);
+        handler = this.extractHandler(module);
+      } else {
+        // CommonJS
+        // Limpa o cache para permitir hot reload em desenvolvimento
+        if (process.env.NODE_ENV === 'development') {
+          delete require.cache[require.resolve(fullPath)];
+        }
+        const module = require(fullPath);
+        handler = this.extractHandler(module);
+      }
+      
+      if (typeof handler !== 'function') {
+        throw new Error(`Handler não é uma função em ${fullPath}. Exporte uma função ou um objeto com handler.`);
+      }
+      
+      logger.debug(`✅ Handler carregado: ${fullPath}`);
+      
+      return handler;
+      
+    } catch (error) {
+      logger.error(`❌ Erro ao carregar handler ${fullPath}:`, error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Extrai a função handler de um módulo
+   * Suporta: module.exports = handler, exports.handler, export default
+   */
+  static extractHandler(module) {
+    // Verifica se é export default
+    if (module.default && typeof module.default === 'function') {
+      return module.default;
+    }
+    
+    // Verifica se é exports.handler
+    if (module.handler && typeof module.handler === 'function') {
+      return module.handler;
+    }
+    
+    // Verifica se o módulo inteiro é uma função
+    if (typeof module === 'function') {
+      return module;
+    }
+    
+    // Tenta encontrar a primeira função exportada
+    const exportedFunctions = Object.values(module).filter(v => typeof v === 'function');
+    if (exportedFunctions.length === 1) {
+      logger.warn(`⚠️ Usando a primeira função exportada como handler: ${exportedFunctions[0].name}`);
+      return exportedFunctions[0];
+    }
+    
+    // Se tem múltiplas funções, tenta encontrar uma chamada 'handler'
+    if (module.handler) {
+      return module.handler;
+    }
+    
+    throw new Error('Não foi possível encontrar uma função handler no módulo');
+  }
+  
+  /**
+   * Detecta o tipo de módulo (CommonJS ou ES Module)
+   */
+  static detectType(filePath) {
+    // Verifica extensão
+    if (filePath.endsWith('.mjs')) {
+      return 'module';
+    }
+    if (filePath.endsWith('.cjs')) {
+      return 'commonjs';
+    }
+    
+    // Verifica package.json na mesma pasta ou superior
+    try {
+      let currentDir = path.dirname(filePath);
+      while (currentDir !== path.parse(currentDir).root) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+          if (packageJson.type === 'module') {
+            return 'module';
+          }
+          break;
+        }
+        currentDir = path.dirname(currentDir);
+      }
+    } catch (error) {
+      // Ignora erro
+    }
+    
+    return 'commonjs';
+  }
+  
+  /**
+   * 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)];
+    
+    // Recarrega
+    return this.load(handlerPath, type);
+  }
+  
+  /**
+   * Valida se um caminho de handler é válido
+   */
+  static isValid(handlerPath) {
+    const fullPath = path.resolve(process.cwd(), handlerPath);
+    return fs.existsSync(fullPath);
+  }
+  
+  /**
+   * Retorna informações sobre o handler
+   */
+  static async getInfo(handlerPath) {
+    const fullPath = path.resolve(process.cwd(), handlerPath);
+    const type = this.detectType(fullPath);
+    const stats = fs.statSync(fullPath);
+    
+    return {
+      path: fullPath,
+      type,
+      exists: fs.existsSync(fullPath),
+      size: stats.size,
+      modified: stats.mtime,
+      isValid: this.isValid(handlerPath)
+    };
+  }
+}
+
+module.exports = HandlerLoader;

package/src/services/lambda/index.js

@@ -0,0 +1,73 @@
+/**
+ * Lambda Service - Ponto de entrada
+ * Exporta o serviço principal e seus componentes
+ */
+
+const LambdaServer = require('./server');
+const LambdaSimulator = require('./simulator');
+
+class LambdaService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'lambda';
+    this.port = config.ports.lambda;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando Lambda Service na porta ${this.port}...`);
+    
+    // Cria o simulador
+    this.simulator = new LambdaSimulator(this.config);
+    
+    // Cria o servidor HTTP
+    this.server = new LambdaServer(this.port, this.config);
+    this.server.simulator = this.simulator;
+    
+    await this.server.initialize();
+    
+    logger.debug('Lambda Service inicializado');
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    await this.server.start();
+    this.isRunning = true;
+  }
+
+  async stop() {
+    if (!this.isRunning) return;
+    await this.server.stop();
+    this.isRunning = false;
+  }
+
+  async reset() {
+    await this.simulator.reset();
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      lambdasCount: this.simulator?.getLambdasCount() || 0
+    };
+  }
+
+  getHandler(path) {
+    return this.simulator?.getHandler(path);
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getServer() {
+    return this.server;
+  }
+}
+
+module.exports = LambdaService;

package/src/services/lambda/route-registry.js

@@ -0,0 +1,275 @@
+/**
+ * Route Registry - Gerencia o registro e matching de rotas para Lambdas
+ * Suporta: Path parameters, Wildcards, Middlewares
+ */
+
+class RouteRegistry {
+  constructor() {
+    this.routes = new Map();
+    this.middlewares = new Map();
+    this.globalMiddlewares = [];
+  }
+
+  /**
+   * Registra uma rota
+   * @param {string} path - Caminho da rota (ex: /users/:id, /api/*)
+   * @param {Function} handler - Função handler da Lambda
+   * @param {Object} env - Variáveis de ambiente específicas
+   * @param {Array} middlewares - Middlewares específicos da rota
+   */
+  register(path, handler, env = {}, middlewares = []) {
+    // Normaliza o path
+    const normalizedPath = this.normalizePath(path);
+    
+    // Parse do path para extrair parâmetros
+    const { pattern, params } = this.parsePath(normalizedPath);
+    
+    this.routes.set(normalizedPath, {
+      path: normalizedPath,
+      pattern,
+      params,
+      handler,
+      env,
+      middlewares,
+      isWildcard: normalizedPath.includes('*'),
+      hasParams: params.length > 0,
+      timestamp: Date.now()
+    });
+    
+    // Adiciona versão com barra se não existir
+    if (!normalizedPath.endsWith('/') && normalizedPath !== '*') {
+      const slashPath = `${normalizedPath}/`;
+      if (!this.routes.has(slashPath)) {
+        this.routes.set(slashPath, {
+          path: slashPath,
+          pattern: this.parsePath(slashPath).pattern,
+          params: this.parsePath(slashPath).params,
+          handler,
+          env,
+          middlewares,
+          isWildcard: false,
+          hasParams: this.parsePath(slashPath).params.length > 0,
+          timestamp: Date.now()
+        });
+      }
+    }
+    
+    return this;
+  }
+
+  /**
+   * Registra um middleware global
+   */
+  use(middleware) {
+    this.globalMiddlewares.push(middleware);
+    return this;
+  }
+
+  /**
+   * Registra um middleware para uma rota específica
+   */
+  useFor(path, middleware) {
+    const normalizedPath = this.normalizePath(path);
+    if (!this.middlewares.has(normalizedPath)) {
+      this.middlewares.set(normalizedPath, []);
+    }
+    this.middlewares.get(normalizedPath).push(middleware);
+    return this;
+  }
+
+  /**
+   * Encontra uma rota que corresponde ao path
+   * @param {string} path - Path da requisição
+   * @returns {Object|null} - Rota encontrada com parâmetros extraídos
+   */
+  find(path) {
+    const normalizedPath = this.normalizePath(path);
+    
+    // Busca exata primeiro
+    if (this.routes.has(normalizedPath)) {
+      const route = this.routes.get(normalizedPath);
+      return {
+        ...route,
+        params: {}
+      };
+    }
+    
+    // Busca por prefixo (para rotas sem parâmetros)
+    for (const [routePath, route] of this.routes.entries()) {
+      if (!route.hasParams && !route.isWildcard && normalizedPath.startsWith(routePath)) {
+        return {
+          ...route,
+          params: {}
+        };
+      }
+    }
+    
+    // Busca por padrão com parâmetros
+    for (const [routePath, route] of this.routes.entries()) {
+      if (route.hasParams && route.pattern) {
+        const match = route.pattern.exec(normalizedPath);
+        if (match) {
+          const params = {};
+          route.params.forEach((paramName, index) => {
+            params[paramName] = match[index + 1];
+          });
+          return {
+            ...route,
+            params
+          };
+        }
+      }
+    }
+    
+    // Busca wildcard
+    for (const [routePath, route] of this.routes.entries()) {
+      if (route.isWildcard) {
+        const wildcardPath = routePath.replace('*', '');
+        if (normalizedPath.startsWith(wildcardPath)) {
+          return {
+            ...route,
+            params: {
+              wildcard: normalizedPath.substring(wildcardPath.length)
+            }
+          };
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Obtém todos os middlewares para uma rota
+   */
+  getMiddlewares(route) {
+    const routeMiddlewares = this.middlewares.get(route.path) || [];
+    return [...this.globalMiddlewares, ...routeMiddlewares, ...route.middlewares];
+  }
+
+  /**
+   * Normaliza o path
+   */
+  normalizePath(path) {
+    // Remove query string
+    const pathWithoutQuery = path.split('?')[0];
+    
+    // Remove trailing slash
+    let normalized = pathWithoutQuery.replace(/\/+$/, '');
+    
+    // Adiciona slash inicial se necessário
+    if (!normalized.startsWith('/')) {
+      normalized = `/${normalized}`;
+    }
+    
+    // Se for vazio, usa root
+    if (normalized === '') {
+      normalized = '/';
+    }
+    
+    return normalized;
+  }
+
+  /**
+   * Parse do path para extrair parâmetros e criar regex pattern
+   * @param {string} path - Path da rota (ex: /users/:id/posts/:postId)
+   * @returns {Object} - { pattern, params }
+   */
+  parsePath(path) {
+    const params = [];
+    
+    // Substitui :param por regex capture group
+    const patternString = path.replace(/:[^\s/]+/g, (match) => {
+      const paramName = match.substring(1);
+      params.push(paramName);
+      return '([^/]+)';
+    });
+    
+    // Substitui * por regex wildcard
+    const finalPatternString = patternString.replace(/\*/g, '(.*)');
+    
+    // Cria regex
+    const pattern = new RegExp(`^${finalPatternString}$`);
+    
+    return { pattern, params };
+  }
+
+  /**
+   * Remove uma rota
+   */
+  unregister(path) {
+    const normalizedPath = this.normalizePath(path);
+    this.routes.delete(normalizedPath);
+    return this;
+  }
+
+  /**
+   * Lista todas as rotas
+   */
+  list() {
+    const routes = [];
+    for (const [path, route] of this.routes.entries()) {
+      routes.push({
+        path,
+        handler: route.handler.name || 'anonymous',
+        hasParams: route.hasParams,
+        isWildcard: route.isWildcard,
+        params: route.params,
+        env: route.env
+      });
+    }
+    return routes;
+  }
+
+  /**
+   * Limpa todas as rotas
+   */
+  clear() {
+    this.routes.clear();
+    this.middlewares.clear();
+    this.globalMiddlewares = [];
+    return this;
+  }
+
+  /**
+   * Verifica se uma rota existe
+   */
+  has(path) {
+    const normalizedPath = this.normalizePath(path);
+    return this.routes.has(normalizedPath) || this.find(path) !== null;
+  }
+
+  /**
+   * Obtém todas as rotas em formato de objeto
+   */
+  getAll() {
+    const result = {};
+    for (const [path, route] of this.routes.entries()) {
+      result[path] = {
+        handler: route.handler,
+        env: route.env,
+        hasParams: route.hasParams,
+        params: route.params
+      };
+    }
+    return result;
+  }
+
+  /**
+   * Obtém estatísticas das rotas
+   */
+  getStats() {
+    const routes = Array.from(this.routes.values());
+    return {
+      total: routes.length,
+      withParams: routes.filter(r => r.hasParams).length,
+      wildcards: routes.filter(r => r.isWildcard).length,
+      routes: routes.map(r => ({
+        path: r.path,
+        handler: r.handler.name || 'anonymous'
+      }))
+    };
+  }
+}
+
+module.exports = RouteRegistry;

package/src/services/lambda/server.js

@@ -0,0 +1,153 @@
+/**
+ * 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',
+        version: require('../../../package.json').version,
+        lambdas: this.simulator.getLambdasCount(),
+        routes: this.simulator.listRoutes()
+      });
+    });
+    
+    // Rota catch-all para todas as Lambdas
+    this.app.all('*', async (req, res) => {
+      const result = await this.simulator.handleRequest(req, res);
+      
+      if (result && result.error) {
+        res.status(result.status).json(result.error);
+      }
+    });
+    
+    // Admin endpoints
+    this.setupAdminRoutes();
+  }
+
+  setupAdminRoutes() {
+    // Listar todas as Lambdas
+    this.app.get('/__admin/lambdas', (req, res) => {
+      res.json(this.simulator.listLambdas());
+    });
+    
+    // Detalhes de uma Lambda
+    this.app.get('/__admin/lambdas/:path', (req, res) => {
+      const lambda = this.simulator.getLambda(req.params.path);
+      if (lambda) {
+        res.json(lambda);
+      } else {
+        res.status(404).json({ error: 'Lambda not found' });
+      }
+    });
+    
+    // Recarregar Lambdas
+    this.app.post('/__admin/reload', async (req, res) => {
+      await this.simulator.reloadLambdas();
+      res.json({ 
+        message: 'Lambdas recarregadas', 
+        count: this.simulator.getLambdasCount() 
+      });
+    });
+    
+    // Injetar variável de ambiente
+    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' });
+      }
+    });
+    
+    // Listar variáveis de ambiente
+    this.app.get('/__admin/env', (req, res) => {
+      res.json(this.simulator.getEnvironmentVariables());
+    });
+    
+    // Estatísticas
+    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.path.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;