@gugananuvem/aws-local-simulator 1.0.0 → 1.0.1

package/src/services/lambda/simulator.js

@@ -0,0 +1,278 @@
+/**
+ * Lambda Simulator - Simula execução de funções Lambda
+ */
+
+const HandlerLoader = require('./handler-loader');
+const RouteRegistry = require('./route-registry');
+const logger = require('../../utils/logger');
+
+class LambdaSimulator {
+  constructor(config) {
+    this.config = config;
+    this.routeRegistry = new RouteRegistry();
+    this.lambdas = new Map();
+    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 { path, handler: handlerPath, env = {}, type = 'auto' } = lambdaConfig;
+      
+      // Carrega o handler
+      const handler = await HandlerLoader.load(handlerPath, type);
+      
+      // Registra no route registry
+      this.routeRegistry.register(path, handler, env);
+      
+      // Armazena metadata
+      this.lambdas.set(path, {
+        path,
+        handler,
+        handlerPath,
+        handlerName: handler.name || 'anonymous',
+        env,
+        type,
+        registeredAt: new Date().toISOString()
+      });
+      
+      logger.debug(`✅ Lambda registrada: ${path} -> ${handler.name || 'anonymous'}`);
+      
+    } catch (error) {
+      logger.error(`❌ Erro ao registrar Lambda ${lambdaConfig.path}:`, error);
+      throw error;
+    }
+  }
+
+  async handleRequest(req, res) {
+    const matchedRoute = this.routeRegistry.find(req.path);
+    
+    if (!matchedRoute) {
+      return {
+        error: {
+          statusCode: 404,
+          message: `Route not found: ${req.path}`,
+          availableRoutes: this.listRoutes()
+        },
+        status: 404
+      };
+    }
+    
+    // Aplica variáveis de ambiente específicas da rota
+    this.applyEnvironment(matchedRoute.env);
+    
+    // Prepara evento Lambda
+    const event = this.toLambdaEvent(req, matchedRoute.params);
+    
+    logger.debug(`🎯 Executando: ${matchedRoute.path} -> ${matchedRoute.handler.name || 'anonymous'}`);
+    
+    // Executa middlewares
+    const middlewares = this.routeRegistry.getMiddlewares(matchedRoute);
+    let handled = false;
+    let result = null;
+    
+    const runMiddlewares = async (index) => {
+      if (index >= middlewares.length) {
+        // Executa handler
+        result = await this.executeHandler(matchedRoute.handler, event);
+        handled = true;
+        return;
+      }
+      
+      const middleware = middlewares[index];
+      await new Promise((resolve, reject) => {
+        middleware(event, {
+          status: (code) => ({ json: (data) => {
+            result = { statusCode: code, body: data };
+            handled = true;
+            resolve();
+          }}),
+          send: (data) => {
+            result = { statusCode: 200, body: data };
+            handled = true;
+            resolve();
+          },
+          next: () => {
+            runMiddlewares(index + 1).then(resolve).catch(reject);
+          }
+        });
+      });
+    };
+    
+    await runMiddlewares(0);
+    
+    if (!handled && result) {
+      return this.formatResponse(result);
+    }
+    
+    return null;
+  }
+
+  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: {
+          error: 'Internal Server Error',
+          message: error.message,
+          stack: process.env.NODE_ENV === 'development' ? error.stack : undefined
+        }
+      };
+    }
+  }
+
+  toLambdaEvent(req, params = {}) {
+    return {
+      httpMethod: req.method,
+      path: req.path,
+      headers: req.headers,
+      queryStringParameters: req.query,
+      pathParameters: params,
+      body: req.body ? (typeof req.body === 'string' ? req.body : JSON.stringify(req.body)) : null,
+      isBase64Encoded: false,
+      requestContext: {
+        path: req.path,
+        stage: process.env.STAGE_NAME || 'dev',
+        requestId: Math.random().toString(36).substring(7),
+        identity: {
+          sourceIp: req.ip,
+          userAgent: req.headers['user-agent']
+        }
+      },
+      stageVariables: {},
+      resource: req.path
+    };
+  }
+
+  formatResponse(result) {
+    const statusCode = result.statusCode || 200;
+    const body = result.body;
+    const headers = result.headers || { 'Content-Type': 'application/json' };
+    
+    return {
+      statusCode,
+      headers,
+      body: typeof body === 'string' ? body : JSON.stringify(body),
+      isBase64Encoded: false
+    };
+  }
+
+  createContext() {
+    return {
+      awsRequestId: Math.random().toString(36).substring(7),
+      functionName: 'local-lambda',
+      functionVersion: '$LATEST',
+      invokedFunctionArn: 'arn:aws:lambda:local:function',
+      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 => ({
+      path: l.path,
+      handlerName: l.handlerName,
+      handlerPath: l.handlerPath,
+      type: l.type,
+      env: l.env,
+      registeredAt: l.registeredAt
+    }));
+  }
+
+  getLambda(path) {
+    return this.lambdas.get(path);
+  }
+
+  listRoutes() {
+    return this.routeRegistry.list();
+  }
+
+  getLambdasCount() {
+    return this.lambdas.size;
+  }
+
+  async reloadLambdas() {
+    logger.info('🔄 Recarregando Lambdas...');
+    
+    for (const [path, lambda] of this.lambdas.entries()) {
+      try {
+        const newHandler = await HandlerLoader.reload(lambda.handlerPath, lambda.type);
+        this.routeRegistry.register(path, newHandler, lambda.env);
+        lambda.handler = newHandler;
+        lambda.handlerName = newHandler.name || 'anonymous';
+        logger.debug(`✅ Lambda recarregada: ${path}`);
+      } catch (error) {
+        logger.error(`❌ Erro ao recarregar Lambda ${path}:`, error);
+      }
+    }
+    
+    logger.info(`✅ ${this.lambdas.size} Lambdas recarregadas`);
+  }
+
+  getStats() {
+    const lambdas = this.listLambdas();
+    return {
+      totalLambdas: lambdas.length,
+      lambdas: lambdas.map(l => ({
+        path: l.path,
+        handler: l.handlerName
+      })),
+      routes: this.routeRegistry.getStats(),
+      environment: Object.keys(this.environment).length
+    };
+  }
+
+  async reset() {
+    // Recarrega Lambdas
+    await this.reloadLambdas();
+    
+    // Limpa variáveis de ambiente customizadas
+    for (const key of Object.keys(this.environment)) {
+      if (!process.env.hasOwnProperty(key) || key.startsWith('AWS_LOCAL_SIMULATOR_')) {
+        delete process.env[key];
+      }
+    }
+    
+    this.environment = { ...process.env };
+    logger.debug('Lambda: Estado resetado');
+  }
+}
+
+module.exports = LambdaSimulator;

package/src/services/s3/index.js

@@ -0,0 +1,70 @@
+/**
+ * S3 Service - Ponto de entrada
+ * Exporta o serviço principal e seus componentes
+ */
+
+const S3Server = require('./server');
+const S3Simulator = require('./simulator');
+
+class S3Service {
+  constructor(config) {
+    this.config = config;
+    this.name = 's3';
+    this.port = config.ports.s3;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando S3 Service na porta ${this.port}...`);
+    
+    // Cria o simulador
+    this.simulator = new S3Simulator(this.config);
+    
+    // Cria o servidor HTTP
+    this.server = new S3Server(this.port, this.config);
+    this.server.simulator = this.simulator;
+    
+    await this.server.initialize();
+    
+    logger.debug('S3 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}`,
+      bucketsCount: this.simulator?.getBucketsCount() || 0,
+      objectsCount: this.simulator?.getTotalObjectsCount() || 0
+    };
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+
+  getServer() {
+    return this.server;
+  }
+}
+
+module.exports = S3Service;

package/src/services/s3/server.js

@@ -0,0 +1,239 @@
+/**
+ * S3 Server - Servidor HTTP para S3
+ */
+
+const express = require('express');
+const S3Simulator = require('./simulator');
+const logger = require('../../utils/logger');
+
+class S3Server {
+  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: '100mb' }));
+    this.app.use(express.raw({ type: 'application/octet-stream', limit: '100mb' }));
+    this.app.use(express.text({ limit: '100mb' }));
+    
+    // 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(`S3: ${req.method} ${req.path} - ${duration}ms`);
+        });
+        next();
+      });
+    }
+  }
+
+  async initialize() {
+    this.simulator = new S3Simulator(this.config);
+    await this.simulator.initialize();
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // Listar buckets
+    this.app.get('/', (req, res) => {
+      const buckets = this.simulator.listBuckets();
+      res.set('Content-Type', 'application/xml');
+      res.send(this.simulator.generateListBucketsResponse(buckets));
+    });
+    
+    // Criar bucket
+    this.app.put('/:bucket', (req, res) => {
+      const result = this.simulator.createBucket(req.params.bucket);
+      if (result.error) {
+        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+      } else {
+        res.status(200).send();
+      }
+    });
+    
+    // Deletar bucket
+    this.app.delete('/:bucket', (req, res) => {
+      const result = this.simulator.deleteBucket(req.params.bucket);
+      if (result.error) {
+        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+      } else {
+        res.status(204).send();
+      }
+    });
+    
+    // Head bucket
+    this.app.head('/:bucket', (req, res) => {
+      const bucket = this.simulator.getBucket(req.params.bucket);
+      if (!bucket) {
+        res.status(404).send();
+      } else {
+        res.status(200).send();
+      }
+    });
+    
+    // Upload object
+    this.app.put('/:bucket/*', (req, res) => {
+      const bucket = req.params.bucket;
+      const key = req.params[0];
+      const result = this.simulator.putObject(bucket, key, req.body, req.headers);
+      
+      if (result.error) {
+        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+      } else {
+        res.set('ETag', `"${result.etag}"`);
+        res.status(200).send();
+      }
+    });
+    
+    // Get object
+    this.app.get('/:bucket/*', (req, res) => {
+      const bucket = req.params.bucket;
+      const key = req.params[0];
+      const result = this.simulator.getObject(bucket, key, req.headers);
+      
+      if (result.error) {
+        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+      } else {
+        res.set('ETag', `"${result.etag}"`);
+        res.set('Last-Modified', result.lastModified);
+        res.set('Content-Type', result.contentType);
+        res.set('Content-Length', result.size);
+        
+        if (result.metadata) {
+          Object.entries(result.metadata).forEach(([k, v]) => {
+            res.set(`x-amz-meta-${k}`, v);
+          });
+        }
+        
+        res.send(result.content);
+      }
+    });
+    
+    // Head object
+    this.app.head('/:bucket/*', (req, res) => {
+      const bucket = req.params.bucket;
+      const key = req.params[0];
+      const result = this.simulator.headObject(bucket, key);
+      
+      if (result.error) {
+        res.status(result.status).send();
+      } else {
+        res.set('ETag', `"${result.etag}"`);
+        res.set('Last-Modified', result.lastModified);
+        res.set('Content-Type', result.contentType);
+        res.set('Content-Length', result.size);
+        res.status(200).send();
+      }
+    });
+    
+    // Delete object
+    this.app.delete('/:bucket/*', (req, res) => {
+      const bucket = req.params.bucket;
+      const key = req.params[0];
+      const result = this.simulator.deleteObject(bucket, key);
+      
+      if (result.error) {
+        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+      } else {
+        res.status(204).send();
+      }
+    });
+    
+    // List objects
+    this.app.get('/:bucket', (req, res) => {
+      const bucket = req.params.bucket;
+      const prefix = req.query.prefix || '';
+      const delimiter = req.query.delimiter;
+      const maxKeys = parseInt(req.query['max-keys']) || 1000;
+      const listType = req.query['list-type'];
+      
+      const result = this.simulator.listObjects(bucket, { prefix, delimiter, maxKeys });
+      
+      if (result.error) {
+        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+      } else {
+        res.set('Content-Type', 'application/xml');
+        if (listType === '2') {
+          res.send(this.simulator.generateListObjectsV2Response(result));
+        } else {
+          res.send(this.simulator.generateListObjectsResponse(result));
+        }
+      }
+    });
+    
+    // Admin endpoints
+    this.setupAdminRoutes();
+  }
+
+  setupAdminRoutes() {
+    this.app.get('/__admin/buckets', (req, res) => {
+      res.json(this.simulator.getBucketsInfo());
+    });
+    
+    this.app.get('/__admin/buckets/:bucket', (req, res) => {
+      const info = this.simulator.getBucketInfo(req.params.bucket);
+      if (info.error) {
+        res.status(404).json(info.error);
+      } else {
+        res.json(info);
+      }
+    });
+    
+    this.app.get('/__admin/buckets/:bucket/objects', (req, res) => {
+      const objects = this.simulator.listAllObjects(req.params.bucket);
+      res.json(objects);
+    });
+    
+    this.app.delete('/__admin/buckets/:bucket', (req, res) => {
+      this.simulator.clearBucket(req.params.bucket);
+      res.json({ message: `Bucket ${req.params.bucket} cleared` });
+    });
+    
+    this.app.delete('/__admin/buckets/:bucket/objects/:key', (req, res) => {
+      this.simulator.deleteObject(req.params.bucket, req.params.key);
+      res.json({ message: 'Object deleted' });
+    });
+    
+    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(`🗄️  S3 rodando em http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  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}`,
+      bucketsCount: this.simulator?.getBucketsCount() || 0,
+      objectsCount: this.simulator?.getTotalObjectsCount() || 0
+    };
+  }
+}
+
+module.exports = S3Server;