@gugananuvem/aws-local-simulator 1.0.0 → 1.0.2

package/src/server.js

@@ -0,0 +1,219 @@
+/**
+ * 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");
+
+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: "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: "apigateway", class: APIGatewayService, 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);
+          }
+
+          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;

package/src/services/apigateway/index.js

@@ -0,0 +1,67 @@
+/**
+ * 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) {
+    this.config = config;
+    this.name = 'apigateway';
+    this.port = config.ports.apigateway || 4567;
+    this.server = null;
+    this.simulator = null;
+    this.isRunning = false;
+  }
+
+  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;
+    
+    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;
+  }
+}
+
+module.exports = APIGatewayService;