@gugananuvem/aws-local-simulator 1.0.22 → 1.0.26

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,

package/src/services/apigateway/simulator.js

@@ -33,6 +33,7 @@ class APIGatewaySimulator {
   async initialize() {
     logger.debug('Inicializando API Gateway Simulator...');
     this.loadAPIs();
+    this._loadStaticAPIs();
     this.loadWebSocketAPIs();
     this.loadDeployments();
     this.loadStages();
@@ -44,9 +45,62 @@ class APIGatewaySimulator {
     this.loadApiKeys();
     this.loadDomainNames();
     
-    logger.debug(`✅ API Gateway Simulator inicializado com ${this.apis.size} APIs, ${this.resources.size} resources, ${this.methods.size} methods`);
+    logger.debug(`✅ API Gateway Simulator inicializado com ${this.apis.size} APIs (${Array.from(this.apis.values()).filter(a => a.isStatic).length} estáticas)`);
   }
 
+  _loadStaticAPIs() {
+    const staticApis = this.config.apigateway?.apis || [];
+    staticApis.forEach((apiConfig, index) => {
+      const apiId = `static_${index}`;
+      
+      const api = {
+        id: apiId,
+        name: apiConfig.name,
+        description: apiConfig.description || 'Configured in aws-local-simulator.json',
+        version: 'config',
+        createdDate: new Date().toISOString(),
+        isStatic: true,
+        apiKeySource: 'HEADER',
+        endpointConfiguration: { types: ['REGIONAL'] },
+        resources: new Map(),
+        stages: new Map(),
+        deployments: new Map(),
+        models: new Map(),
+        authorizers: new Map()
+      };
+      
+      // Adiciona recursos a partir dos endpoints configurados
+      (apiConfig.endpoints || []).forEach((ep, epIndex) => {
+        const resId = `res_${apiId}_${epIndex}`;
+        api.resources.set(resId, {
+          id: resId,
+          path: ep.path,
+          pathPart: ep.path.split('/').pop() || '/',
+          resourceMethods: new Map([[ep.method, {
+            httpMethod: ep.method,
+            authorizationType: ep.authorizerRequired ? 'COGNITO_USER_POOLS' : 'NONE',
+            apiKeyRequired: false,
+            integration: {
+              type: ep.integrationType === 'lambda' ? 'AWS_PROXY' : 'HTTP',
+              uri: ep.lambdaName,
+              integrationHttpMethod: 'POST'
+            }
+          }]])
+        });
+      });
+      
+      // Adiciona um stage padrão
+      api.stages.set('local', {
+        stageName: 'local',
+        createdDate: new Date().toISOString(),
+        deploymentId: 'static-deploy'
+      });
+      
+      this.apis.set(apiId, api);
+    });
+  }
+
+
   // ============ REST API Operations ============
 
   createRestApi(params) {
@@ -104,11 +158,15 @@ class APIGatewaySimulator {
         description: api.description,
         version: api.version,
         createdDate: api.createdDate,
-        apiKeySource: api.apiKeySource
+        apiKeySource: api.apiKeySource,
+        isStatic: api.isStatic || false,
+        resourceCount: api.resources.size,
+        stageCount: api.stages.size
       }))
     };
   }
 
+
   getRestApi(params) {
     const { restApiId } = params;
     const api = this.apis.get(restApiId);
@@ -129,6 +187,27 @@ class APIGatewaySimulator {
     };
   }
 
+  updateRestApi(params) {
+    const { restApiId, name, description } = params;
+    const api = this.apis.get(restApiId);
+    
+    if (!api) {
+      throw new Error(`API ${restApiId} not found`);
+    }
+    
+    if (name !== undefined) api.name = name;
+    if (description !== undefined) api.description = description;
+    
+    if (api.isStatic) {
+      // Once edited, the API is no longer static and will be persisted
+      api.isStatic = false;
+    }
+    
+    this.persistAPIs();
+    
+    return this.getRestApi({ restApiId });
+  }
+
   deleteRestApi(params) {
     const { restApiId } = params;
     
@@ -142,8 +221,67 @@ class APIGatewaySimulator {
     return {};
   }
 
+  // ============ Simplified Dashboard Endpoint Operations ============
+
+  putEndpoint(params) {
+    const { restApiId, path, method, integrationType, lambdaName, authorizerRequired } = params;
+    const api = this.apis.get(restApiId);
+    if (!api) throw new Error(`API ${restApiId} not found`);
+
+    if (api.isStatic) api.isStatic = false;
+
+    // Ensure resource exists
+    let resource = Array.from(api.resources.values()).find(r => r.path === path);
+    if (!resource) {
+      const resourceId = `res_${Date.now()}`;
+      resource = {
+        id: resourceId,
+        path: path,
+        pathPart: path.split('/').pop() || '/',
+        parentId: null, // Simplified
+        resourceMethods: new Map()
+      };
+      api.resources.set(resourceId, resource);
+    }
+
+    // Put method
+    resource.resourceMethods.set(method.toUpperCase(), {
+      httpMethod: method.toUpperCase(),
+      authorizationType: authorizerRequired ? 'COGNITO_USER_POOLS' : 'NONE',
+      apiKeyRequired: false,
+      integration: {
+        type: integrationType === 'lambda' ? 'AWS_PROXY' : 'HTTP',
+        uri: lambdaName,
+        integrationHttpMethod: 'POST'
+      }
+    });
+
+    this.persistAPIs();
+    return { resourceId: resource.id, path, method };
+  }
+
+  deleteEndpoint(params) {
+    const { restApiId, path, method } = params;
+    const api = this.apis.get(restApiId);
+    if (!api) throw new Error(`API ${restApiId} not found`);
+
+    if (api.isStatic) api.isStatic = false;
+
+    const resource = Array.from(api.resources.values()).find(r => r.path === path);
+    if (resource) {
+      resource.resourceMethods.delete(method.toUpperCase());
+      // If no methods left and not root, we could delete the resource, but keeping it is fine.
+      if (resource.resourceMethods.size === 0 && resource.path !== '/') {
+        api.resources.delete(resource.id);
+      }
+      this.persistAPIs();
+    }
+    return {};
+  }
+
   // ============ Resource Operations ============
 
+
   createResource(params) {
     const { restApiId, parentId, pathPart } = params;
     const api = this.apis.get(restApiId);
@@ -1054,7 +1192,10 @@ class APIGatewaySimulator {
     if (saved) {
       for (const [id, data] of Object.entries(saved)) {
         // Reconstitui Maps
-        data.resources = new Map(Object.entries(data.resources || {}));
+        data.resources = new Map(Object.entries(data.resources || {}).map(([rid, r]) => {
+          r.resourceMethods = new Map(Object.entries(r.resourceMethods || {}));
+          return [rid, r];
+        }));
         data.stages = new Map(Object.entries(data.stages || {}));
         data.deployments = new Map(Object.entries(data.deployments || {}));
         data.models = new Map(Object.entries(data.models || {}));
@@ -1064,6 +1205,7 @@ class APIGatewaySimulator {
     }
   }
 
+
   loadWebSocketAPIs() {
     const saved = this.store.read('__websocket_apis__');
     if (saved) {
@@ -1157,9 +1299,10 @@ class APIGatewaySimulator {
   persistAPIs() {
     const apisObj = {};
     for (const [id, api] of this.apis.entries()) {
+      if (api.isStatic) continue;
       apisObj[id] = {
         ...api,
-        resources: Object.fromEntries(api.resources),
+        resources: Object.fromEntries(Array.from(api.resources.entries()).map(([rid, r]) => [rid, { ...r, resourceMethods: Object.fromEntries(r.resourceMethods) }])),
         stages: Object.fromEntries(api.stages),
         deployments: Object.fromEntries(api.deployments),
         models: Object.fromEntries(api.models),
@@ -1169,6 +1312,7 @@ class APIGatewaySimulator {
     this.store.write('__apis__', apisObj);
   }
 
+
   persistResources(apiId) {
     const api = this.apis.get(apiId);
     if (api) {

package/src/services/cognito/server.js

@@ -18,19 +18,10 @@ class CognitoServer {
 
   setupMiddlewares() {
     this.app.use(cors());
-    this.app.use(express.raw({ type: '*/*', limit: '10mb' }));
-    this.app.use((req, res, next) => {
-      if (req.body && Buffer.isBuffer(req.body)) {
-        try {
-          req.body = JSON.parse(req.body.toString('utf8'));
-        } catch (e) {
-          req.body = {};
-        }
-      } else if (!req.body) {
-        req.body = {};
-      }
-      next();
-    });
+    this.app.use(express.json({
+      limit: '10mb',
+      type: ['application/json', 'application/x-amz-json-1.1']
+    }));
     
     if (logger.currentLogLevel === 'verboso') {
       this.app.use((req, res, next) => {
@@ -73,7 +64,8 @@ class CognitoServer {
 
       try {
         const result = await this.handleRequest(target, req.body || {});
-        res.json(result);
+        res.setHeader('Content-Type', 'application/x-amz-json-1.1');
+        res.send(JSON.stringify(result));
       } catch (error) {
         logger.error('Cognito Error:', error.message);
         res.status(400).json({
@@ -108,6 +100,8 @@ class CognitoServer {
         return this.simulator.describeUserPool(params);
       case 'DeleteUserPool':
         return this.simulator.deleteUserPool(params);
+      case 'UpdateUserPool':
+        return this.simulator.updateUserPool(params);
       
       case 'ListUsers':
         return this.simulator.listUsers(params);