@gugananuvem/aws-local-simulator 1.0.11 → 1.0.14

package/src/server.js

@@ -12,11 +12,21 @@ const DynamoDBService = require("./services/dynamodb");
 const S3Service = require("./services/s3");
 const SQSService = require("./services/sqs");
 const LambdaService = require("./services/lambda");
-const SNSService = require("./services/sns");
-const EventBridgeService = require("./services/eventbridge");
+const { SNSService } = require("./services/sns");
+const { EventBridgeService } = require("./services/eventbridge");
 const CognitoService = require("./services/cognito");
 const APIGatewayService = require("./services/apigateway");
 const ECSService = require("./services/ecs");
+const STSService = require("./services/sts");
+const { CloudWatchService } = require("./services/cloudwatch");
+const CloudTrailService = require("./services/cloudtrail");
+const { KMSService } = require("./services/kms");
+const CloudFormationService = require("./services/cloudformation");
+const { XRayService } = require("./services/xray");
+const { SecretManagerService } = require("./services/secret-manager");
+const { ParameterStoreService } = require("./services/parameter-store");
+const { ConfigService } = require("./services/config");
+const { AthenaService } = require("./services/athena");
 
 class Server {
   constructor(config) {
@@ -63,23 +73,31 @@ class Server {
   }
 
   async initializeServices() {
-    // Ordem de inicialização importante
     const serviceOrder = [
-      { name: "lambda", class: LambdaService, depends: [] },
-      { name: "dynamodb", class: DynamoDBService, depends: [] },
-      { name: "s3", class: S3Service, depends: [] },
-      { name: "sqs", class: SQSService, depends: ["lambda"] },
-      { name: "sns", class: SNSService, depends: [] },
-      { name: "eventbridge", class: EventBridgeService, depends: [] },
-      { name: "cognito", class: CognitoService, depends: [] },
-      { name: "ecs", class: ECSService, depends: [] },
-      { name: "apigateway", class: APIGatewayService, depends: [] },
+      { name: "sts",            class: STSService,            depends: [] },
+      { name: "lambda",         class: LambdaService,         depends: [] },
+      { name: "dynamodb",       class: DynamoDBService,       depends: [] },
+      { name: "s3",             class: S3Service,             depends: [] },
+      { name: "sqs",            class: SQSService,            depends: ["lambda"] },
+      { name: "sns",            class: SNSService,            depends: [] },
+      { name: "eventbridge",    class: EventBridgeService,    depends: [] },
+      { name: "cognito",        class: CognitoService,        depends: [] },
+      { name: "ecs",            class: ECSService,            depends: [] },
+      { name: "apigateway",     class: APIGatewayService,     depends: ["lambda"] },
+      { name: "kms",            class: KMSService,            depends: [] },
+      { name: "cloudwatch",     class: CloudWatchService,     depends: [] },
+      { name: "cloudtrail",     class: CloudTrailService,     depends: [] },
+      { name: "cloudformation", class: CloudFormationService, depends: [] },
+      { name: "xray",           class: XRayService,           depends: [] },
+      { name: "secret-manager", class: SecretManagerService,  depends: [] },
+      { name: "parameter-store",class: ParameterStoreService, depends: [] },
+      { name: "config",         class: ConfigService,         depends: [] },
+      { name: "athena",         class: AthenaService,         depends: [] },
     ];
 
     for (const serviceDef of serviceOrder) {
       if (this.config.services[serviceDef.name]) {
         try {
-          // Resolve dependências
           const dependencies = {};
           for (const dep of serviceDef.depends) {
             dependencies[dep] = this.servicesMap.get(dep);
@@ -94,29 +112,17 @@ class Server {
           logger.success(`✅ ${serviceDef.name.toUpperCase()} Service inicializado`);
         } catch (error) {
           logger.error(`❌ Erro ao inicializar ${serviceDef.name}:`, error);
-          if (serviceDef.name === "lambda") {
-            throw error; // Lambda é essencial
-          }
+          if (serviceDef.name === "lambda") throw error;
         }
       }
     }
 
-    /*
-    // Cognito Service (opcional)
-    if (this.config.services.cognito) {
-      const cognitoService = new CognitoService(this.config);
-      await cognitoService.initialize();
-      this.services.push(cognitoService);
-      this.servicesMap.set("cognito", cognitoService);
-      logger.success("✅ Cognito Service inicializado");
+    // Injeta dependências cross-service nos serviços que suportam
+    for (const service of this.services) {
+      if (typeof service.injectDependencies === "function") {
+        service.injectDependencies(this);
+      }
     }
-    if (this.config.services.apigateway) {
-      const apigatewayService = new APIGatewayService(this.config);
-      await apigatewayService.initialize();
-      this.services.push(apigatewayService);
-      this.servicesMap.set("apigateway", apigatewayService);
-      logger.success("✅ API Gateway Service inicializado");
-    }*/
   }
 
   async startServices() {

package/src/services/apigateway/index.js

@@ -7,30 +7,37 @@ const APIGatewayServer = require('./server');
 const APIGatewaySimulator = require('./simulator');
 
 class APIGatewayService {
-  constructor(config) {
+  constructor(config, dependencies = {}) {
     this.config = config;
     this.name = 'apigateway';
     this.port = config.ports.apigateway || 4567;
     this.server = null;
     this.simulator = null;
     this.isRunning = false;
+    this.lambdaService = dependencies.lambda || null;
   }
 
   async initialize() {
     const logger = require('../../utils/logger');
     logger.debug(`Inicializando API Gateway Service na porta ${this.port}...`);
-    
+
     this.simulator = new APIGatewaySimulator(this.config);
     await this.simulator.initialize();
-    
+
     this.server = new APIGatewayServer(this.port, this.config);
     this.server.simulator = this.simulator;
+    this.server.lambdaService = this.lambdaService;
     
     await this.server.initialize();
     
     logger.debug('API Gateway Service inicializado');
   }
 
+  injectDependencies(server) {
+    const ct = server.getService('cloudtrail');
+    if (ct?.simulator) this.simulator.audit.setTrail(ct.simulator);
+  }
+
   async start() {
     if (this.isRunning) return;
     await this.server.start();

package/src/services/apigateway/server.js

@@ -19,6 +19,26 @@ class APIGatewayServer {
   setupMiddlewares() {
     this.app.use(express.json({ limit: '10mb' }));
     this.app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+    // Parse bodies with AWS content types (e.g. application/x-amz-json-1.1)
+    this.app.use((req, res, next) => {
+      const ct = req.headers['content-type'] || ''; 
+      if ((req.body && JSON.stringify(req.body) == "{}") && ct.includes('application/x-amz-json')) {
+        let data = "";
+        req.on("data", (chunk) => {
+          data += chunk;
+        });
+        req.on("end", () => {
+          try {
+            req.body = JSON.parse(data);
+          } catch (error) {
+            req.body = {};
+          }
+          next();
+        });
+      } else {
+        next();
+      }      
+    });
     this.app.use(cors());
     
     if (logger.currentLogLevel === 'verboso') {
@@ -35,10 +55,63 @@ class APIGatewayServer {
 
   async initialize() {
     this.setupRoutes();
+    this.setupConfigRoutes();
     this.setupProxyRoutes();
     logger.debug('API Gateway Server inicializado');
   }
 
+  setupConfigRoutes() {
+    // Register routes from aws-local-simulator.json config directly
+    const apis = this.config.apigateway?.apis || [];
+    for (const api of apis) {
+      for (const endpoint of (api.endpoints || [])) {
+        const { path, method, lambdaName, integrationType } = endpoint;
+        if (!path || !method) continue;
+
+        const expressPath = path.replace(/\{([^}]+)\}/g, ':$1');
+        const httpMethod = method.toLowerCase();
+
+        logger.debug(`📡 Registrando rota: ${method} ${path} -> ${lambdaName}`);
+
+        this.app[httpMethod](expressPath, async (req, res) => {
+          try {
+            const lambdaService = this.lambdaService;
+            if (!lambdaService) {
+              return res.status(500).json({ error: 'Lambda service not available' });
+            }
+
+            const event = {
+              httpMethod: req.method,
+              path: req.path,
+              headers: req.headers,
+              queryStringParameters: Object.keys(req.query).length ? req.query : null,
+              pathParameters: Object.keys(req.params).length ? req.params : null,
+              body: req.body ? JSON.stringify(req.body) : null,
+              isBase64Encoded: false,
+              requestContext: {
+                path: req.path,
+                stage: 'local',
+                requestId: Math.random().toString(36).substring(7),
+                identity: { sourceIp: req.ip }
+              }
+            };
+
+            const result = await lambdaService.simulator.invoke(lambdaName, event);
+            const payload = result.Payload || {};
+            const statusCode = payload.statusCode || 200;
+            const headers = payload.headers || { 'Content-Type': 'application/json' };
+            const body = payload.body;
+
+            res.status(statusCode).set(headers).send(body);
+          } catch (err) {
+            logger.error(`Lambda invoke error (${lambdaName}):`, err);
+            res.status(500).json({ error: err.message });
+          }
+        });
+      }
+    }
+  }
+
   setupRoutes() {
     // Health check
     this.app.get('/health', (req, res) => {

package/src/services/apigateway/simulator.js

@@ -9,14 +9,15 @@ const logger = require('../../utils/logger');
 const LocalStore = require('../../utils/local-store');
 const path = require('path');
 const { URLPattern } = require('urlpattern-polyfill');
+const { CloudTrailAudit } = require('../../utils/cloudtrail-audit');
 
 class APIGatewaySimulator {
   constructor(config) {
     this.config = config;
     this.dataDir = path.join(process.env.AWS_LOCAL_SIMULATOR_DATA_DIR, 'apigateway');
     this.store = new LocalStore(this.dataDir);
-    this.apis = new Map();           // REST/HTTP APIs
-    this.websocketApis = new Map();  // WebSocket APIs
+    this.apis = new Map();
+    this.websocketApis = new Map();
     this.deployments = new Map();
     this.stages = new Map();
     this.resources = new Map();
@@ -26,6 +27,7 @@ class APIGatewaySimulator {
     this.usagePlans = new Map();
     this.apiKeys = new Map();
     this.domainNames = new Map();
+    this.audit = new CloudTrailAudit('execute-api.amazonaws.com');
   }
 
   async initialize() {
@@ -734,7 +736,15 @@ class APIGatewaySimulator {
       response.headers = { ...response.headers, ...integrationResponse.responseParameters };
       response.body = this.applyResponseTemplate(integrationResponse, response.body);
     }
-    
+
+    this.audit.record({
+      eventName: 'Invoke',
+      readOnly: method === 'GET' || method === 'HEAD',
+      isDataEvent: true,
+      resources: [{ ARN: `arn:aws:execute-api:local:000000000000:${apiId}/${stageName}/${method}${path}`, type: 'AWS::APIGateway::Stage' }],
+      requestParameters: { apiId, stageName, method, path },
+    });
+
     return response;
   }
 

package/src/services/athena/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const http = require('http');
+const path = require('path');
+const { AthenaSimulator } = require('./simulator');
+const { createAthenaServer } = require('./server');
+const LocalStore = require('../../utils/local-store');
+
+class AthenaService {
+  constructor(config) {
+    this.config = config;
+    this.logger = require('../../utils/logger');
+    this.name = 'athena';
+    this.port = config?.ports?.athena || 4599;
+    this.store = null;
+    this.simulator = null;
+    this._server = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    this.logger.debug(`Inicializando Athena Service na porta ${this.port}...`);
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+    this.store = new LocalStore(path.join(dataDir, 'athena'));
+    this.simulator = new AthenaSimulator(this.config, this.store, this.logger);
+    await this.simulator.initialize();
+    this.app = createAthenaServer(this.simulator, this.logger);
+    this.logger.debug('Athena Service inicializado');
+  }
+
+  injectDependencies(server) {
+    const ct = server.getService('cloudtrail');
+    if (ct?.simulator) this.simulator.audit.setTrail(ct.simulator);
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    return new Promise((resolve, reject) => {
+      this._server = http.createServer(this.app);
+      this._server.listen(this.port, () => {
+        this.isRunning = true;
+        this.logger.info(`🔍 Athena rodando em http://localhost:${this.port}`);
+        resolve();
+      });
+      this._server.on('error', reject);
+    });
+  }
+
+  async stop() {
+    if (!this.isRunning || !this._server) return;
+    return new Promise((resolve) => {
+      this._server.close(() => {
+        this.isRunning = false;
+        resolve();
+      });
+    });
+  }
+
+  async reset() {
+    await this.simulator.reset();
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      ...this.simulator?.getStats(),
+    };
+  }
+
+  getSimulator() { return this.simulator; }
+}
+
+module.exports = { AthenaService };

package/src/services/athena/server.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const express = require('express');
+const cors = require('cors');
+
+/**
+ * Athena Server - protocolo JSON via x-amz-target
+ */
+function createAthenaServer(simulator, logger) {
+  const app = express();
+
+  app.use(cors());
+  app.use(express.json({ limit: '10mb', type: () => true }));
+
+  app.use((req, _res, next) => {
+    const target = req.headers['x-amz-target'] || '';
+    if (target) logger.debug(`[Athena] ${req.method} ${req.path} target=${target}`);
+    next();
+  });
+
+  // ── Rota principal ───────────────────────────────────────────────
+  app.post('/', async (req, res) => {
+    const target = (req.headers['x-amz-target'] || '').replace('AmazonAthena.', '');
+    const body = req.body || {};
+
+    try {
+      let result;
+
+      switch (target) {
+        case 'StartQueryExecution':
+          result = await simulator.startQueryExecution(body);
+          break;
+        case 'GetQueryExecution':
+          result = simulator.getQueryExecution(body);
+          break;
+        case 'GetQueryResults':
+          result = simulator.getQueryResults(body);
+          break;
+        case 'StopQueryExecution':
+          result = await simulator.stopQueryExecution(body);
+          break;
+        case 'ListQueryExecutions':
+          result = simulator.listQueryExecutions(body);
+          break;
+        case 'CreateNamedQuery':
+          result = await simulator.createNamedQuery(body);
+          break;
+        case 'GetNamedQuery':
+          result = simulator.getNamedQuery(body);
+          break;
+        case 'ListNamedQueries':
+          result = simulator.listNamedQueries(body);
+          break;
+        case 'DeleteNamedQuery':
+          result = await simulator.deleteNamedQuery(body);
+          break;
+        case 'CreateWorkGroup':
+          result = await simulator.createWorkGroup(body);
+          break;
+        case 'GetWorkGroup':
+          result = simulator.getWorkGroup(body);
+          break;
+        case 'ListWorkGroups':
+          result = simulator.listWorkGroups(body);
+          break;
+        case 'DeleteWorkGroup':
+          result = await simulator.deleteWorkGroup(body);
+          break;
+        default:
+          return res.status(400).json({ __type: 'InvalidRequestException', message: `Unknown action: ${target}` });
+      }
+
+      res.json(result || {});
+    } catch (err) {
+      logger.error(`[Athena] Error in ${target}: ${err.message}`);
+      res.status(err.statusCode || 500).json({ __type: err.code || 'InternalServerError', message: err.message });
+    }
+  });
+
+  // ── Admin ────────────────────────────────────────────────────────
+  app.get('/__admin/health', (_req, res) => {
+    res.json({ status: 'healthy', service: 'athena', ...simulator.getStats() });
+  });
+
+  app.get('/__admin/executions', (_req, res) => {
+    res.json({ executions: Array.from(simulator.queryExecutions.values()).map(({ _results, ...e }) => e) });
+  });
+
+  app.get('/__admin/workgroups', (_req, res) => {
+    res.json({ workGroups: Array.from(simulator.workGroups.values()) });
+  });
+
+  app.post('/__admin/reset', async (_req, res) => {
+    await simulator.reset();
+    res.json({ message: 'Athena data reset complete' });
+  });
+
+  return app;
+}
+
+module.exports = { createAthenaServer };