@gugananuvem/aws-local-simulator 1.0.12 → 1.0.15

package/src/server.js

@@ -1,223 +1,227 @@
-/**
- * Servidor Principal - Orquestra todos os serviços
- */
-
-const path = require("path");
-const fs = require("fs");
-const mkdirp = require("mkdirp");
-const logger = require("./utils/logger");
-
-// Importa serviços
-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 CognitoService = require("./services/cognito");
-const APIGatewayService = require("./services/apigateway");
-const ECSService = require("./services/ecs");
-const STSService = require("./services/sts");
-
-class Server {
-  constructor(config) {
-    this.config = config;
-    this.services = [];
-    this.servicesMap = new Map();
-    this.running = false;
-    this.setupDataDir();
-    this.setupLogLevel();
-  }
-
-  setupDataDir() {
-    const dataDir = path.resolve(process.cwd(), this.config.dataDir);
-    if (!fs.existsSync(dataDir)) {
-      mkdirp.sync(dataDir);
-      logger.debug(`📁 Diretório de dados criado: ${dataDir}`);
-    }
-    process.env.AWS_LOCAL_SIMULATOR_DATA_DIR = dataDir;
-  }
-
-  setupLogLevel() {
-    logger.setLevel(this.config.logLevel);
-    logger.info(`📝 Nível de log: ${this.config.logLevel}`);
-  }
-
-  async start() {
-    if (this.running) {
-      logger.warn("Servidor já está rodando");
-      return;
-    }
-
-    logger.info("\n🚀 Iniciando AWS Local Simulator...\n");
-
-    try {
-      await this.initializeServices();
-      await this.startServices();
-
-      this.running = true;
-      this.printStatus();
-    } catch (error) {
-      logger.error("❌ Erro ao iniciar servidor:", error);
-      throw error;
-    }
-  }
-
-  async initializeServices() {
-    // Ordem de inicialização importante
-    const serviceOrder = [
-      { 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"] },
-    ];
-
-    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);
-          }
-
-          const service = new serviceDef.class(this.config, dependencies);
-          await service.initialize();
-
-          this.services.push(service);
-          this.servicesMap.set(serviceDef.name, service);
-
-          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
-          }
-        }
-      }
-    }
-
-    /*
-    // 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");
-    }
-    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() {
-    const startPromises = this.services.map((service) => service.start());
-    await Promise.all(startPromises);
-    logger.success("\n🎉 Todos os serviços foram iniciados com sucesso!");
-  }
-
-  async stop() {
-    if (!this.running) {
-      logger.warn("Servidor não está rodando");
-      return;
-    }
-
-    logger.info("\n🛑 Parando AWS Local Simulator...\n");
-
-    try {
-      const stopPromises = [...this.services].reverse().map((service) => service.stop());
-      await Promise.all(stopPromises);
-
-      this.running = false;
-      logger.success("✅ Todos os serviços foram parados");
-    } catch (error) {
-      logger.error("❌ Erro ao parar servidor:", error);
-      throw error;
-    }
-  }
-
-  async reset() {
-    logger.info("\n🗑️ Resetando todos os dados...\n");
-
-    const resetPromises = this.services.map((service) => service.reset());
-    await Promise.all(resetPromises);
-
-    logger.success("✅ Todos os dados foram resetados");
-  }
-
-  getStatus() {
-    const status = {
-      running: this.running,
-      services: {},
-    };
-
-    for (const service of this.services) {
-      status.services[service.name] = service.getStatus();
-    }
-
-    return status;
-  }
-
-  getService(name) {
-    return this.servicesMap.get(name);
-  }
-
-  printStatus() {
-    logger.info("\n" + "=".repeat(60));
-    logger.info("📊 Status dos Serviços:");
-    logger.info("=".repeat(60));
-
-    for (const service of this.services) {
-      const status = service.getStatus();
-      logger.info(`\n${service.name.toUpperCase()}:`);
-      logger.info(`  Status: ${status.running ? "✅ Rodando" : "❌ Parado"}`);
-      logger.info(`  Porta: ${status.port}`);
-      logger.info(`  Endpoint: ${status.endpoint}`);
-
-      if (status.tablesCount !== undefined) {
-        logger.info(`  Tabelas: ${status.tablesCount}`);
-      }
-      if (status.bucketsCount !== undefined) {
-        logger.info(`  Buckets: ${status.bucketsCount}`);
-      }
-      if (status.queuesCount !== undefined) {
-        logger.info(`  Filas: ${status.queuesCount}`);
-      }
-      if (status.lambdasCount !== undefined) {
-        logger.info(`  Lambdas: ${status.lambdasCount}`);
-      }
-      if (status.objectsCount !== undefined) {
-        logger.info(`  Objetos: ${status.objectsCount}`);
-      }
-      if (status.messagesCount !== undefined) {
-        logger.info(`  Mensagens: ${status.messagesCount}`);
-      }
-    }
-
-    logger.info("\n" + "=".repeat(60));
-    logger.info("\n📝 Comandos úteis:");
-    logger.info("  AWS CLI:");
-    logger.info("    aws dynamodb list-tables --endpoint-url http://localhost:8000");
-    logger.info("    aws s3 ls --endpoint-url http://localhost:4566");
-    logger.info("    aws sqs list-queues --endpoint-url http://localhost:9324");
-    logger.info("\n  Testar APIs:");
-    logger.info("    curl http://localhost:3001/health");
-    logger.info("    curl http://localhost:8000/__admin/tables");
-    logger.info("    curl http://localhost:4566/__admin/buckets");
-    logger.info("    curl http://localhost:9324/__admin/queues");
-    logger.info("=".repeat(60) + "\n");
-  }
-}
-
-module.exports = Server;
+/**
+ * Servidor Principal - Orquestra todos os serviços
+ */
+
+const path = require("path");
+const fs = require("fs");
+const mkdirp = require("mkdirp");
+const logger = require("./utils/logger");
+
+// Importa serviços
+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 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) {
+    this.config = config;
+    this.services = [];
+    this.servicesMap = new Map();
+    this.running = false;
+    this.setupDataDir();
+    this.setupLogLevel();
+  }
+
+  setupDataDir() {
+    const dataDir = path.resolve(process.cwd(), this.config.dataDir);
+    if (!fs.existsSync(dataDir)) {
+      mkdirp.sync(dataDir);
+      logger.debug(`📁 Diretório de dados criado: ${dataDir}`);
+    }
+    process.env.AWS_LOCAL_SIMULATOR_DATA_DIR = dataDir;
+  }
+
+  setupLogLevel() {
+    logger.setLevel(this.config.logLevel);
+    logger.info(`📝 Nível de log: ${this.config.logLevel}`);
+  }
+
+  async start() {
+    if (this.running) {
+      logger.warn("Servidor já está rodando");
+      return;
+    }
+
+    logger.info("\n🚀 Iniciando AWS Local Simulator...\n");
+
+    try {
+      await this.initializeServices();
+      await this.startServices();
+
+      this.running = true;
+      this.printStatus();
+    } catch (error) {
+      logger.error("❌ Erro ao iniciar servidor:", error);
+      throw error;
+    }
+  }
+
+  async initializeServices() {
+    const serviceOrder = [
+      { 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: ["lambda"] },
+      { 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 {
+          const dependencies = {};
+          for (const dep of serviceDef.depends) {
+            dependencies[dep] = this.servicesMap.get(dep);
+          }
+
+          const service = new serviceDef.class(this.config, dependencies);
+          await service.initialize();
+
+          this.services.push(service);
+          this.servicesMap.set(serviceDef.name, service);
+
+          logger.success(`✅ ${serviceDef.name.toUpperCase()} Service inicializado`);
+        } catch (error) {
+          logger.error(`❌ Erro ao inicializar ${serviceDef.name}:`, error);
+          if (serviceDef.name === "lambda") throw error;
+        }
+      }
+    }
+
+    // Injeta dependências cross-service nos serviços que suportam
+    for (const service of this.services) {
+      if (typeof service.injectDependencies === "function") {
+        service.injectDependencies(this);
+      }
+    }
+  }
+
+  async startServices() {
+    const startPromises = this.services.map((service) => service.start());
+    await Promise.all(startPromises);
+    logger.success("\n🎉 Todos os serviços foram iniciados com sucesso!");
+  }
+
+  async stop() {
+    if (!this.running) {
+      logger.warn("Servidor não está rodando");
+      return;
+    }
+
+    logger.info("\n🛑 Parando AWS Local Simulator...\n");
+
+    try {
+      const stopPromises = [...this.services].reverse().map((service) => service.stop());
+      await Promise.all(stopPromises);
+
+      this.running = false;
+      logger.success("✅ Todos os serviços foram parados");
+    } catch (error) {
+      logger.error("❌ Erro ao parar servidor:", error);
+      throw error;
+    }
+  }
+
+  async reset() {
+    logger.info("\n🗑️ Resetando todos os dados...\n");
+
+    const resetPromises = this.services.map((service) => service.reset());
+    await Promise.all(resetPromises);
+
+    logger.success("✅ Todos os dados foram resetados");
+  }
+
+  getStatus() {
+    const status = {
+      running: this.running,
+      services: {},
+    };
+
+    for (const service of this.services) {
+      status.services[service.name] = service.getStatus();
+    }
+
+    return status;
+  }
+
+  getService(name) {
+    return this.servicesMap.get(name);
+  }
+
+  printStatus() {
+    logger.info("\n" + "=".repeat(60));
+    logger.info("📊 Status dos Serviços:");
+    logger.info("=".repeat(60));
+
+    for (const service of this.services) {
+      const status = service.getStatus();
+      logger.info(`\n${service.name.toUpperCase()}:`);
+      logger.info(`  Status: ${status.running ? "✅ Rodando" : "❌ Parado"}`);
+      logger.info(`  Porta: ${status.port}`);
+      logger.info(`  Endpoint: ${status.endpoint}`);
+
+      if (status.tablesCount !== undefined) {
+        logger.info(`  Tabelas: ${status.tablesCount}`);
+      }
+      if (status.bucketsCount !== undefined) {
+        logger.info(`  Buckets: ${status.bucketsCount}`);
+      }
+      if (status.queuesCount !== undefined) {
+        logger.info(`  Filas: ${status.queuesCount}`);
+      }
+      if (status.lambdasCount !== undefined) {
+        logger.info(`  Lambdas: ${status.lambdasCount}`);
+      }
+      if (status.objectsCount !== undefined) {
+        logger.info(`  Objetos: ${status.objectsCount}`);
+      }
+      if (status.messagesCount !== undefined) {
+        logger.info(`  Mensagens: ${status.messagesCount}`);
+      }
+    }
+
+    logger.info("\n" + "=".repeat(60));
+    logger.info("\n📝 Comandos úteis:");
+    logger.info("  AWS CLI:");
+    logger.info("    aws dynamodb list-tables --endpoint-url http://localhost:8000");
+    logger.info("    aws s3 ls --endpoint-url http://localhost:4566");
+    logger.info("    aws sqs list-queues --endpoint-url http://localhost:9324");
+    logger.info("\n  Testar APIs:");
+    logger.info("    curl http://localhost:3001/health");
+    logger.info("    curl http://localhost:8000/__admin/tables");
+    logger.info("    curl http://localhost:4566/__admin/buckets");
+    logger.info("    curl http://localhost:9324/__admin/queues");
+    logger.info("=".repeat(60) + "\n");
+  }
+}
+
+module.exports = Server;

package/src/services/apigateway/index.js

@@ -1,69 +1,74 @@
-/**
- * API Gateway Service - Simulador de Amazon API Gateway
- * Suporta: REST APIs, HTTP APIs, WebSocket APIs, Stages, Deployments
- */
-
-const APIGatewayServer = require('./server');
-const APIGatewaySimulator = require('./simulator');
-
-class APIGatewayService {
-  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');
-  }
-
-  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}`,
-      apisCount: this.simulator?.getAPIsCount() || 0,
-      deploymentsCount: this.simulator?.getDeploymentsCount() || 0,
-      stagesCount: this.simulator?.getStagesCount() || 0,
-      resourcesCount: this.simulator?.getResourcesCount() || 0
-    };
-  }
-
-  getSimulator() {
-    return this.simulator;
-  }
-}
-
+/**
+ * API Gateway Service - Simulador de Amazon API Gateway
+ * Suporta: REST APIs, HTTP APIs, WebSocket APIs, Stages, Deployments
+ */
+
+const APIGatewayServer = require('./server');
+const APIGatewaySimulator = require('./simulator');
+
+class APIGatewayService {
+  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();
+    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}`,
+      apisCount: this.simulator?.getAPIsCount() || 0,
+      deploymentsCount: this.simulator?.getDeploymentsCount() || 0,
+      stagesCount: this.simulator?.getStagesCount() || 0,
+      resourcesCount: this.simulator?.getResourcesCount() || 0
+    };
+  }
+
+  getSimulator() {
+    return this.simulator;
+  }
+}
+
 module.exports = APIGatewayService;