@gugananuvem/aws-local-simulator 1.0.25 → 1.0.26

package/README.md

@@ -186,6 +186,50 @@ npx aws-local-simulator reset
 npx aws-local-simulator status
 ```
 
+## 🖥️ Management API
+
+O simulador expõe uma API de gerenciamento em tempo de execução na porta `9999` (configurável via `adminPort`). Ela permite habilitar e desabilitar serviços individualmente sem reiniciar o processo.
+
+### Endpoints da Management API
+
+| Método | Rota | Descrição |
+|--------|------|-----------|
+| GET | `/__admin/services` | Lista todos os 19 serviços com status |
+| GET | `/__admin/services/:name` | Status de um serviço específico |
+| POST | `/__admin/services/:name/enable` | Habilita um serviço parado |
+| POST | `/__admin/services/:name/disable` | Desabilita um serviço em execução |
+
+### Exemplos
+
+```bash
+# Listar todos os serviços
+curl http://localhost:9999/__admin/services
+
+# Habilitar DynamoDB
+curl -X POST http://localhost:9999/__admin/services/dynamodb/enable
+
+# Desabilitar SQS
+curl -X POST http://localhost:9999/__admin/services/sqs/disable
+
+# Status de um serviço
+curl http://localhost:9999/__admin/services/lambda
+```
+
+### Configuração da porta admin
+
+```json
+{
+  "adminPort": 9999
+}
+```
+
+Ou via variável de ambiente:
+```bash
+AWS_LOCAL_SIMULATOR_ADMIN_PORT=9999 npx aws-local-simulator start
+```
+
+> A Management API nunca persiste alterações em disco — todo o estado é mantido em memória. Para uso em desenvolvimento local apenas.
+
 ## 🔌 Endpoints
 
 | Serviço | Endpoint | Admin |
@@ -210,6 +254,7 @@ npx aws-local-simulator status
 | CloudFormation | http://localhost:4580 | http://localhost:4580/__admin/stacks |
 | Athena | http://localhost:4599 | http://localhost:4599/__admin/health |
 | ECS | http://localhost:8080 | http://localhost:8080/__admin/clusters |
+| Management API | http://localhost:9999 | http://localhost:9999/__admin/services |
 
 ## 🧪 Testando com AWS CLI
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -9,31 +9,30 @@
   "scripts": {
     "start": "node bin/aws-local-simulator.js start"
   },
-  "jest": {
-    "setupFilesAfterEnv": [
-      "<rootDir>/tests/setup.js"
-    ],
-    "testEnvironment": "node",
-    "testMatch": [
-      "**/tests/**/*.test.js"
-    ],
-    "collectCoverageFrom": [
-      "src/**/*.js",
-      "!src/templates/**",
-      "!**/node_modules/**"
-    ],
-    "coverageThreshold": {
-      "global": {
-        "branches": 30,
-        "functions": 30,
-        "lines": 30,
-        "statements": 30
-      }
-    },
-    "verbose": true,
-    "testTimeout": 30000,
-    "forceExit": true,
-    "detectOpenHandles": true
+  "dependencies": {
+    "@aws-sdk/client-api-gateway": "^3.0.0",
+    "@aws-sdk/client-cognito-identity-provider": "^3.0.0",
+    "@aws-sdk/client-dynamodb": "^3.0.0",
+    "@aws-sdk/client-ecs": "^3.0.0",
+    "@aws-sdk/client-lambda": "^3.0.0",
+    "@aws-sdk/client-s3": "^3.0.0",
+    "@aws-sdk/client-sqs": "^3.0.0",
+    "@aws-sdk/lib-dynamodb": "^3.0.0",
+    "child_process": "1.0.2",
+    "cors": "^2.8.5",
+    "crypto": "1.0.1",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "fs": "0.0.1-security",
+    "glob": "10.5.0",
+    "http": "0.0.1-security",
+    "js-yaml": "4.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "mkdirp": "^3.0.1",
+    "path": "0.12.7",
+    "url": "0.11.4",
+    "urlpattern-polyfill": "^10.0.0",
+    "uuid": "14.0.0"
   },
   "keywords": [
     "aws",
@@ -43,21 +42,7 @@
     "s3",
     "sqs",
     "lambda",
-    "cognito",
-    "apigateway",
-    "kms",
-    "config",
-    "parameter-store",
-    "secret-manager",
-    "cloudformation",
-    "eventbridge",
-    "sns",
-    "ecs",
-    "sts",
-    "cloudtrail",
-    "cloudwatch",
-    "development",
-    "testing"
+    "cognito"
   ],
   "author": {
     "name": "gugananuvem",
@@ -69,7 +54,7 @@
     "url": "git+https://github.com/gugananuvem/aws-local-simulator.git"
   },
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
     "src/",
@@ -81,46 +66,6 @@
   "publishConfig": {
     "directory": "dist"
   },
-  "dependencies": {
-    "cors": "^2.8.5",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "glob": "10.5.0",
-    "jsonwebtoken": "^9.0.2",
-    "mkdirp": "^3.0.1",
-    "urlpattern-polyfill": "^10.0.0",
-    "uuid": "14.0.0"
-  },
-  "peerDependencies": {
-    "@aws-sdk/client-api-gateway": "^3.0.0",
-    "@aws-sdk/client-cognito-identity-provider": "^3.0.0",
-    "@aws-sdk/client-dynamodb": "^3.0.0",
-    "@aws-sdk/client-ecs": "^3.0.0",
-    "@aws-sdk/client-lambda": "^3.1032.0",
-    "@aws-sdk/client-s3": "^3.0.0",
-    "@aws-sdk/client-sqs": "^3.0.0",
-    "@aws-sdk/lib-dynamodb": "^3.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@aws-sdk/client-dynamodb": {
-      "optional": true
-    },
-    "@aws-sdk/client-s3": {
-      "optional": true
-    },
-    "@aws-sdk/client-sqs": {
-      "optional": true
-    },
-    "@aws-sdk/client-cognito-identity-provider": {
-      "optional": true
-    },
-    "@aws-sdk/client-api-gateway": {
-      "optional": true
-    },
-    "@aws-sdk/client-ecs": {
-      "optional": true
-    }
-  },
-  "buildDate": "2026-04-24T17:52:50.093Z",
+  "buildDate": "2026-04-27T11:03:00.202Z",
   "published": true
 }

package/src/config/default-config.js

@@ -9,12 +9,16 @@ module.exports = {
     s3: true,
     sqs: true,
     lambda: true,
-    sns: false,
-    eventbridge: false,
+    sns: true,
+    eventbridge: true,
     ecs: false,
-    cognito: false,
-    apigateway: false,
+    cognito: true,
+    apigateway: true,
     sts: true,
+    "secret-manager": true,
+    "parameter-store": true,
+    kms: true,
+    kinesis: true,
   },
 
   // Portas padrão
@@ -30,6 +34,10 @@ module.exports = {
     apigateway: 4567,
     sts: 9326,
     athena: 4599,
+    secretManager: 4001,
+    parameterStore: 4002,
+    kms: 4000,
+    kinesis: 4568,
   },
   apigateway: {
     defaultCors: {
@@ -65,4 +73,7 @@ module.exports = {
 
   // Configurações adicionais
   additional: {},
+
+  // Porta do servidor de administração (Management API)
+  adminPort: 9999,
 };

package/src/server.js

@@ -5,6 +5,8 @@
 const path = require("path");
 const fs = require("fs");
 const mkdirp = require("mkdirp");
+const express = require("express");
+const cors = require("cors");
 const logger = require("./utils/logger");
 
 // Importa serviços
@@ -34,6 +36,10 @@ class Server {
     this.services = [];
     this.servicesMap = new Map();
     this.running = false;
+    this.managementApp = express();
+    this.managementApp.use(cors());
+    this.managementApp.use(express.json());
+    this.managementServer = null;
     this.setupDataDir();
     this.setupLogLevel();
   }
@@ -63,6 +69,8 @@ class Server {
     try {
       await this.initializeServices();
       await this.startServices();
+      this.setupManagementRoutes();
+      await this.startManagementServer();
 
       this.running = true;
       this.printStatus();
@@ -72,28 +80,150 @@ class Server {
     }
   }
 
-  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", "cognito"] },
-      { 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: [] },
+  setupManagementRoutes() {
+    const app = this.managementApp;
+
+    // GET /__admin/services — returns all services status
+    app.get("/__admin/services", (req, res) => {
+      const registry = this.buildServiceRegistry();
+      const services = registry.map((def) => {
+        const svc = this.servicesMap.get(def.name);
+        if (svc) {
+          const status = typeof svc.getStatus === "function"
+            ? svc.getStatus()
+            : { name: def.name, running: true, port: svc.port };
+          // Compute canDisable: no running service should depend on this one
+          const canDisable = !registry.some(
+            (other) =>
+              other.depends.includes(def.name) &&
+              this.servicesMap.has(other.name)
+          );
+          return {
+            name: def.name,
+            running: true,
+            enabled: true,
+            port: status.port || this.config.ports?.[def.name],
+            endpoint: status.endpoint || `http://localhost:${status.port || this.config.ports?.[def.name]}`,
+            dependencies: def.depends,
+            category: def.category,
+            canDisable,
+            ...status,
+          };
+        }
+        return {
+          name: def.name,
+          running: false,
+          enabled: false,
+          port: this.config.ports?.[def.name],
+          endpoint: `http://localhost:${this.config.ports?.[def.name]}`,
+          dependencies: def.depends,
+          canDisable: true,
+        };
+      });
+      res.json({ services });
+    });
+
+    // GET /__admin/services/:name — returns single service status
+    app.get("/__admin/services/:name", (req, res) => {
+      const { name } = req.params;
+      const registry = this.buildServiceRegistry();
+      const def = registry.find((d) => d.name === name);
+      if (!def) {
+        return res.status(404).json({ error: `Unknown service: ${name}` });
+      }
+      const svc = this.servicesMap.get(name);
+      const canDisable = !registry.some(
+        (other) =>
+          other.depends.includes(name) &&
+          this.servicesMap.has(other.name)
+      );
+      if (svc) {
+        const status = typeof svc.getStatus === "function"
+          ? svc.getStatus()
+          : { name, running: true, port: svc.port };
+        return res.json({
+          name,
+          running: true,
+          enabled: true,
+          port: status.port || this.config.ports?.[name],
+          endpoint: status.endpoint || `http://localhost:${status.port || this.config.ports?.[name]}`,
+          dependencies: def.depends,
+          canDisable,
+          ...status,
+        });
+      }
+      return res.json({
+        name,
+        running: false,
+        enabled: false,
+        port: this.config.ports?.[name],
+        endpoint: `http://localhost:${this.config.ports?.[name]}`,
+        dependencies: def.depends,
+        canDisable: true,
+      });
+    });
+
+    // POST /__admin/services/:name/enable — enables a service
+    app.post("/__admin/services/:name/enable", async (req, res) => {
+      const result = await this.enableService(req.params.name);
+      res.status(result.success ? 200 : 400).json(result);
+    });
+
+    // POST /__admin/services/:name/disable — disables a service
+    app.post("/__admin/services/:name/disable", async (req, res) => {
+      const result = await this.disableService(req.params.name);
+      res.status(result.success ? 200 : 400).json(result);
+    });
+  }
+
+  startManagementServer() {
+    return new Promise((resolve, reject) => {
+      const port = this.config.adminPort || 9999;
+      this.managementServer = this.managementApp.listen(port, () => {
+        logger.info(`🔧 Management API rodando em http://localhost:${port}`);
+        resolve();
+      });
+      this.managementServer.on("error", reject);
+    });
+  }
+
+  buildServiceRegistry() {
+    return [
+      //Armazenamento & BD
+      { name: "dynamodb", class: DynamoDBService, depends: [], category: 'Armazenamento & Banco de Dados' },
+      { name: "s3", class: S3Service, depends: [], category: 'Armazenamento & Banco de Dados' },
+      { name: "athena", class: AthenaService, depends: [], category: 'Armazenamento & Banco de Dados' },
+
+      //Computação
+      { name: "lambda", class: LambdaService, depends: [], category: 'Computação' },
+      /*      { name: "ecs",            class: ECSService,            depends: [] , category:'Computação'},*/
+
+      { name: "cognito", class: CognitoService, depends: ["lambda"], category: 'Segurança & Identidade' },
+      { name: "sts", class: STSService, depends: [], category: 'Segurança & Identidade' },
+      { name: "kms", class: KMSService, depends: [], category: 'Segurança & Identidade' },
+      { name: "secret-manager", class: SecretManagerService, depends: [], category: 'Segurança & Identidade' },
+      { name: "parameter-store", class: ParameterStoreService, depends: [], category: 'Segurança & Identidade' },
+
+      //Mensageria
+      { name: "sqs", class: SQSService, depends: ["lambda"], category: 'Mensageria & Integração' },
+      { name: "sns", class: SNSService, depends: [], category: 'Mensageria & Integração' },
+      { name: "eventbridge", class: EventBridgeService, depends: [], category: 'Mensageria & Integração' },
+
+      //Networking
+      { name: "apigateway", class: APIGatewayService, depends: ["lambda", "cognito"], category: 'Networking' },
+
+      //Observabilidade & Conformidade
+      { name: "cloudwatch", class: CloudWatchService, depends: [], category: 'Observabilidade & Conformidade' },
+      { name: "cloudtrail", class: CloudTrailService, depends: [], category: 'Observabilidade & Conformidade' },
+      { name: "xray", class: XRayService, depends: [], category: 'Observabilidade & Conformidade' },
+      { name: "config", class: ConfigService, depends: [], category: 'Observabilidade & Conformidade' },
+      { name: "cloudformation", class: CloudFormationService, depends: [], category: 'Observabilidade & Conformidade' },
+
     ];
+  }
+
+  async initializeServices() {
+    const serviceOrder = this.buildServiceRegistry();
 
     for (const serviceDef of serviceOrder) {
       if (this.config.services[serviceDef.name]) {
@@ -143,6 +273,11 @@ class Server {
       const stopPromises = [...this.services].reverse().map((service) => service.stop());
       await Promise.all(stopPromises);
 
+      if (this.managementServer) {
+        await new Promise((resolve) => this.managementServer.close(resolve));
+        this.managementServer = null;
+      }
+
       this.running = false;
       logger.success("✅ Todos os serviços foram parados");
     } catch (error) {
@@ -177,6 +312,107 @@ class Server {
     return this.servicesMap.get(name);
   }
 
+  async enableService(name) {
+    // Check if already running
+    if (this.servicesMap.has(name)) {
+      return { success: false, error: "Service already running" };
+    }
+
+    // Look up in registry
+    const registry = this.buildServiceRegistry();
+    const serviceDef = registry.find((s) => s.name === name);
+    if (!serviceDef) {
+      return { success: false, error: "Unknown service" };
+    }
+
+    // Validate all dependencies are running
+    for (const dep of serviceDef.depends) {
+      if (!this.servicesMap.has(dep)) {
+        return { success: false, error: `Dependency not running: ${dep}` };
+      }
+    }
+
+    try {
+      const service = new serviceDef.class(this.config);
+      await service.initialize();
+      await service.start();
+
+      this.services.push(service);
+      this.servicesMap.set(name, service);
+
+      if (typeof service.injectDependencies === "function") {
+        service.injectDependencies(this);
+      }
+
+      // Build ServiceStatus for the response
+      const canDisable = !registry.some(
+        (other) =>
+          other.depends.includes(name) && this.servicesMap.has(other.name)
+      );
+      const rawStatus =
+        typeof service.getStatus === "function"
+          ? service.getStatus()
+          : { name, running: true, port: service.port };
+
+      const serviceStatus = {
+        name,
+        running: true,
+        enabled: true,
+        port: rawStatus.port || this.config.ports?.[name],
+        endpoint:
+          rawStatus.endpoint ||
+          `http://localhost:${rawStatus.port || this.config.ports?.[name]}`,
+        dependencies: serviceDef.depends,
+        canDisable,
+        ...rawStatus,
+      };
+
+      return { success: true, service: serviceStatus };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
+  async disableService(name) {
+    // Check if running
+    const service = this.servicesMap.get(name);
+    if (!service) {
+      return { success: false, error: "Service not running" };
+    }
+
+    // Check reverse dependencies
+    const registry = this.buildServiceRegistry();
+    for (const other of registry) {
+      if (other.depends.includes(name) && this.servicesMap.has(other.name)) {
+        return {
+          success: false,
+          error: `Cannot disable: ${other.name} depends on it`,
+        };
+      }
+    }
+
+    try {
+      await service.stop();
+      this.services = this.services.filter((s) => s !== service);
+      this.servicesMap.delete(name);
+
+      return {
+        success: true,
+        service: {
+          name,
+          running: false,
+          enabled: false,
+          port: this.config.ports?.[name],
+          endpoint: `http://localhost:${this.config.ports?.[name]}`,
+          dependencies: registry.find((d) => d.name === name)?.depends || [],
+          canDisable: true,
+        },
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+
   printStatus() {
     logger.info("\n" + "=".repeat(60));
     logger.info("📊 Status dos Serviços:");

package/src/services/apigateway/server.js

@@ -209,6 +209,18 @@ class APIGatewayServer {
       }
     });
 
+    this.app.patch('/restapis/:apiId', (req, res) => {
+      try {
+        const result = this.simulator.updateRestApi({
+          ...req.body,
+          restApiId: req.params.apiId
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
     this.app.delete('/restapis/:apiId', (req, res) => {
       try {
         this.simulator.deleteRestApi({ restApiId: req.params.apiId });
@@ -509,6 +521,31 @@ class APIGatewayServer {
       }
     });
 
+    this.app.post('/__admin/apis/:apiId/endpoints', (req, res) => {
+      try {
+        const result = this.simulator.putEndpoint({
+          ...req.body,
+          restApiId: req.params.apiId
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
+    this.app.delete('/__admin/apis/:apiId/endpoints', (req, res) => {
+      try {
+        const result = this.simulator.deleteEndpoint({
+          restApiId: req.params.apiId,
+          path: req.query.path,
+          method: req.query.method
+        });
+        res.json(result);
+      } catch (error) {
+        res.status(400).json({ error: error.message });
+      }
+    });
+
     this.app.get('/__admin/apikeys', (req, res) => {
       const keys = Array.from(this.simulator.apiKeys.values()).map(k => ({
         id: k.id,