@gugananuvem/aws-local-simulator 1.0.11 → 1.0.12

package/src/services/lambda/simulator.js

@@ -3,42 +3,40 @@
  */
 
 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.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 { path, handler: handlerPath, env = {}, type = 'auto' } = lambdaConfig;
-      
-      // Carrega o handler
+      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);
-      
-      // Registra no route registry
-      this.routeRegistry.register(path, handler, env);
-      
-      // Armazena metadata
-      this.lambdas.set(path, {
-        path,
+
+      this.lambdas.set(name, {
+        name,
         handler,
         handlerPath,
         handlerName: handler.name || 'anonymous',
@@ -46,84 +44,33 @@ class LambdaSimulator {
         type,
         registeredAt: new Date().toISOString()
       });
-      
-      logger.debug(`✅ Lambda registrada: ${path} -> ${handler.name || 'anonymous'}`);
-      
+
+      logger.debug(`✅ Lambda registrada: ${name} -> ${handlerPath}`);
     } catch (error) {
-      logger.error(`❌ Erro ao registrar Lambda ${lambdaConfig.path}:`, error);
+      logger.error(`❌ Erro ao registrar Lambda ${lambdaConfig.name}:`, 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
-      };
+  async invoke(functionName, event, invocationType = 'RequestResponse') {
+    const lambda = this.lambdas.get(functionName);
+
+    if (!lambda) {
+      throw new Error(`Function not found: ${functionName}`);
     }
-    
-    // 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;
-      
-        console.log(`✅ Resposta: ${result.statusCode}`);
-        res
-          .status(result.statusCode || 200)
-          .set(result.headers || {})
-          .send(result.body ? JSON.parse(result.body) : null);
-        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);
+    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 };
     }
 
-    return null;
+    const result = await this.executeHandler(lambda.handler, event);
+    return { StatusCode: result.statusCode || 200, Payload: result };
   }
 
   async executeHandler(handler, event) {
@@ -135,57 +82,17 @@ class LambdaSimulator {
       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
-        }
+        body: JSON.stringify({ error: 'Internal Server Error', message: error.message })
       };
     }
   }
 
-  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',
+      invokedFunctionArn: 'arn:aws:lambda:local:000000000000:function:local-lambda',
       memoryLimitInMB: '1024',
       logGroupName: '/aws/lambda/local-lambda',
       logStreamName: 'local-stream',
@@ -214,7 +121,7 @@ class LambdaSimulator {
 
   listLambdas() {
     return Array.from(this.lambdas.values()).map(l => ({
-      path: l.path,
+      name: l.name,
       handlerName: l.handlerName,
       handlerPath: l.handlerPath,
       type: l.type,
@@ -223,12 +130,8 @@ class LambdaSimulator {
     }));
   }
 
-  getLambda(path) {
-    return this.lambdas.get(path);
-  }
-
-  listRoutes() {
-    return this.routeRegistry.list();
+  getLambda(name) {
+    return this.lambdas.get(name);
   }
 
   getLambdasCount() {
@@ -237,49 +140,33 @@ class LambdaSimulator {
 
   async reloadLambdas() {
     logger.info('🔄 Recarregando Lambdas...');
-    
-    for (const [path, lambda] of this.lambdas.entries()) {
+
+    for (const [name, 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}`);
+        logger.debug(`✅ Lambda recarregada: ${name}`);
       } catch (error) {
-        logger.error(`❌ Erro ao recarregar Lambda ${path}:`, error);
+        logger.error(`❌ Erro ao recarregar Lambda ${name}:`, 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
+      totalLambdas: this.lambdas.size,
+      lambdas: this.listLambdas().map(l => ({ name: l.name, handler: l.handlerName }))
     };
   }
 
   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;
+module.exports = LambdaSimulator;

package/src/services/sqs/server.js

@@ -3,6 +3,7 @@
  */
 
 const express = require('express');
+const crypto = require('crypto');
 const SQSSimulator = require('./simulator');
 const logger = require('../../utils/logger');
 
@@ -18,8 +19,23 @@ class SQSServer {
   }
 
   setupMiddlewares() {
-    this.app.use(express.json());
-    this.app.use(express.urlencoded({ extended: true }));
+    this.app.use(express.raw({ type: '*/*', limit: '10mb' }));
+    this.app.use((req, res, next) => {
+      if (req.body && Buffer.isBuffer(req.body)) {
+        const str = req.body.toString('utf8');
+        const contentType = req.headers['content-type'] || '';
+        if (contentType.includes('application/x-amz-json-1.0') || contentType.includes('application/json')) {
+          try { req.body = JSON.parse(str); } catch (e) { req.body = {}; }
+        } else if (contentType.includes('application/x-www-form-urlencoded')) {
+          req.body = Object.fromEntries(new URLSearchParams(str));
+        } else {
+          try { req.body = JSON.parse(str); } catch (e) { req.body = {}; }
+        }
+      } else if (!req.body) {
+        req.body = {};
+      }
+      next();
+    });
     
     // Logging de requisições
     if (logger.currentLogLevel === 'verboso') {
@@ -42,16 +58,35 @@ class SQSServer {
 
   setupRoutes() {
     // Endpoint principal
+    this.app.use((req, res, next) => {
+      logger.info(`SQS incoming: ${req.method} ${req.path} headers=${JSON.stringify(req.headers)} query=${JSON.stringify(req.query)} body=${JSON.stringify(req.body)}`);
+      next();
+    });
+
     this.app.post('/', (req, res) => {
-      const action = req.query.Action || req.body.Action;
+      const action = req.query.Action || req.body.Action ||
+        (req.headers['x-amz-target'] && req.headers['x-amz-target'].split('.')[1]);
+      logger.info(`SQS action resolved: ${action}`);
       const result = this.simulator.handleRequest(action, req, res);
-      
+      const isJsonProtocol = req.headers['content-type'] && req.headers['content-type'].includes('application/x-amz-json-1.0');
+
       if (result && result.error) {
-        res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+        const isJsonProtocol = req.headers['content-type'] && req.headers['content-type'].includes('application/x-amz-json-1.0');
+        if (isJsonProtocol) {
+          res.status(result.status).json({ __type: result.error.code, message: result.error.message });
+        } else {
+          res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+        }
       } else if (result) {
-        // Gera resposta XML
-        res.set('Content-Type', 'application/xml');
-        res.send(this.generateResponse(action, result));
+        if (isJsonProtocol) {
+          res.set('Content-Type', 'application/x-amz-json-1.0');
+          res.json(this.generateJsonResponse(action, result));
+        } else {
+          const xml = this.generateResponse(action, result);
+          logger.info(`SQS response for ${action}: ${xml}`);
+          res.set('Content-Type', 'application/xml');
+          res.send(xml);
+        }
       }
     });
     
@@ -105,6 +140,37 @@ class SQSServer {
     });
   }
 
+  generateJsonResponse(action, result) {
+    switch (action) {
+      case 'CreateQueue':
+        return { QueueUrl: result.queueUrl };
+      case 'SendMessage':
+        return { MD5OfMessageBody: result.md5, MessageId: result.messageId };
+      case 'SendMessageBatch':
+        return {
+          Successful: (result.successful || []).map(s => ({ Id: s.Id, MessageId: s.MessageId, MD5OfMessageBody: s.MD5OfMessageBody })),
+          Failed: result.failed || []
+        };
+      case 'ReceiveMessage':
+        return {
+          Messages: (result.messages || []).map(m => ({
+            MessageId: m.MessageId,
+            ReceiptHandle: m.ReceiptHandle,
+            MD5OfBody: m.MD5OfBody,
+            Body: m.Body
+          }))
+        };
+      case 'DeleteMessage':
+        return {};
+      case 'GetQueueUrl':
+        return { QueueUrl: result.queueUrl };
+      case 'ListQueues':
+        return { QueueUrls: (result.queues || []).map(q => q.url) };
+      default:
+        return result;
+    }
+  }
+
   generateResponse(action, result) {
     switch(action) {
       case 'CreateQueue':
@@ -128,26 +194,28 @@ class SQSServer {
 
   generateCreateQueueResponse(queueUrl) {
     return `<?xml version="1.0" encoding="UTF-8"?>
-<CreateQueueResponse>
+<CreateQueueResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <CreateQueueResult>
     <QueueUrl>${queueUrl}</QueueUrl>
   </CreateQueueResult>
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
 </CreateQueueResponse>`;
   }
 
   generateSendMessageResponse(messageId, md5) {
     return `<?xml version="1.0" encoding="UTF-8"?>
-<SendMessageResponse>
+<SendMessageResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <SendMessageResult>
     <MD5OfMessageBody>${md5}</MD5OfMessageBody>
     <MessageId>${messageId}</MessageId>
   </SendMessageResult>
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
 </SendMessageResponse>`;
   }
 
   generateSendMessageBatchResponse(successful, failed) {
     let xml = `<?xml version="1.0" encoding="UTF-8"?>
-<SendMessageBatchResponse>
+<SendMessageBatchResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <SendMessageBatchResult>`;
     
     for (const s of successful) {
@@ -170,6 +238,7 @@ class SQSServer {
     
     xml += `
   </SendMessageBatchResult>
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
 </SendMessageBatchResponse>`;
     
     return xml;
@@ -177,7 +246,7 @@ class SQSServer {
 
   generateReceiveMessageResponse(messages) {
     let xml = `<?xml version="1.0" encoding="UTF-8"?>
-<ReceiveMessageResponse>
+<ReceiveMessageResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <ReceiveMessageResult>`;
     
     for (const msg of messages) {
@@ -192,6 +261,7 @@ class SQSServer {
     
     xml += `
   </ReceiveMessageResult>
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
 </ReceiveMessageResponse>`;
     
     return xml;
@@ -199,25 +269,26 @@ class SQSServer {
 
   generateDeleteMessageResponse() {
     return `<?xml version="1.0" encoding="UTF-8"?>
-<DeleteMessageResponse>
+<DeleteMessageResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <ResponseMetadata>
-    <RequestId>${Math.random().toString(36).substring(7)}</RequestId>
+    <RequestId>${crypto.randomUUID()}</RequestId>
   </ResponseMetadata>
 </DeleteMessageResponse>`;
   }
 
   generateGetQueueUrlResponse(queueUrl) {
     return `<?xml version="1.0" encoding="UTF-8"?>
-<GetQueueUrlResponse>
+<GetQueueUrlResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <GetQueueUrlResult>
     <QueueUrl>${queueUrl}</QueueUrl>
   </GetQueueUrlResult>
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
 </GetQueueUrlResponse>`;
   }
 
   generateListQueuesResponse(queues) {
     let xml = `<?xml version="1.0" encoding="UTF-8"?>
-<ListQueuesResponse>
+<ListQueuesResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
   <ListQueuesResult>`;
     
     for (const queue of queues) {
@@ -226,6 +297,7 @@ class SQSServer {
     
     xml += `
   </ListQueuesResult>
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
 </ListQueuesResponse>`;
     
     return xml;