@gugananuvem/aws-local-simulator 1.0.11 → 1.0.12

package/README.md

@@ -13,10 +13,11 @@ Simulador local completo para serviços AWS. Desenvolva e teste suas aplicaçõe
 | DynamoDB | ✅ | 8000 | Banco de dados NoSQL |
 | S3 | ✅ | 4566 | Armazenamento de objetos |
 | SQS | ✅ | 9324 | Filas de mensagens |
-| Lambda | ✅ | 3001 | Funções serverless |
+| Lambda | ✅ | 3001 | Funções serverless (invocação por nome) |
 | Cognito | ✅ | 9229 | Autenticação e autorização |
 | API Gateway | ✅ | 4567 | APIs REST e HTTP |
-| ECS/Fargate |  🚧 | 8080 | Orquestração de containers (em desenvolvimento) |
+| STS | ✅ | 9326 | Credenciais temporárias (AssumeRole, GetCallerIdentity) |
+| ECS/Fargate | 🚧 | 8080 | Orquestração de containers (em desenvolvimento) |
 | SNS | 🚧 | 9911 | Notificações (em desenvolvimento) |
 | EventBridge | 🚧 | 4010 | Barramento de eventos (em desenvolvimento) |
 
@@ -25,8 +26,11 @@ Simulador local completo para serviços AWS. Desenvolva e teste suas aplicaçõe
 ```bash
 npm install --save-dev aws-local-simulator
 ```
-🚀 Uso Rápido
-1. Crie um arquivo de configuração aws-local-simulator.json:
+
+## 🚀 Uso Rápido
+
+### 1. Crie um arquivo de configuração `aws-local-simulator.json`:
+
 ```json
 {
   "services": {
@@ -35,11 +39,12 @@ npm install --save-dev aws-local-simulator
     "sqs": true,
     "lambda": true,
     "cognito": true,
-    "apigateway": true
+    "apigateway": true,
+    "sts": true
   },
   "lambdas": [
     {
-      "path": "/api/users",
+      "name": "my-function",
       "handler": "./src/handlers/users.js",
       "env": {
         "TABLE_NAME": "users-table"
@@ -50,18 +55,17 @@ npm install --save-dev aws-local-simulator
     "tables": [
       {
         "TableName": "users-table",
-        "KeySchema": [
-          { "AttributeName": "id", "KeyType": "HASH" }
-        ],
-        "AttributeDefinitions": [
-          { "AttributeName": "id", "AttributeType": "S" }
-        ]
+        "KeySchema": [{ "AttributeName": "id", "KeyType": "HASH" }],
+        "AttributeDefinitions": [{ "AttributeName": "id", "AttributeType": "S" }]
       }
     ]
   },
   "s3": {
     "buckets": ["my-bucket"]
   },
+  "sqs": {
+    "queues": ["my-queue", "dead-letter-queue"]
+  },
   "cognito": {
     "userPools": [
       {
@@ -73,80 +77,86 @@ npm install --save-dev aws-local-simulator
 }
 ```
 
-# 2. Inicie o simulador:
-## Via CLI
+### 2. Inicie o simulador:
+
+```bash
+# Via CLI
 npx aws-local-simulator start
 
 # Ou via código
 const { AWSLocalSimulator } = require('aws-local-simulator');
 const simulator = new AWSLocalSimulator();
 await simulator.start();
+```
 
-# 3. Configure seu código para usar os serviços locais:
+### 3. Configure seu código para usar os serviços locais:
 
 ```javascript
-// Importe a configuração AWS pronta
-const { dynamoDB, s3, sqs, cognito, apigateway } = require('aws-local-simulator/aws-config');
+const { dynamoDB, s3, sqs, cognito } = require('aws-local-simulator/aws-config');
 
-// Use como normalmente faria
 await dynamoDB.send(new PutCommand({
   TableName: 'users-table',
   Item: { id: '123', name: 'John' }
 }));
 ```
 
-🔧 Configuração por Variáveis de Ambiente
+## 🔧 Configuração por Variáveis de Ambiente
 
 | Variável | Descrição | Padrão |
 |---------|----------|-------|
-| AWS_LOCAL_SIMULATOR_DYNAMODB |Habilita DynamoDB | true |
-| AWS_LOCAL_SIMULATOR_S3 |Habilita S3 | true |
-| AWS_LOCAL_SIMULATOR_SQS |Habilita SQS | true |
-| AWS_LOCAL_SIMULATOR_LAMBDA |Habilita Lambda | true |
-| AWS_LOCAL_SIMULATOR_COGNITO |Habilita Cognito | false |
-| AWS_LOCAL_SIMULATOR_APIGATEWAY |Habilita API Gateway | false |
-| AWS_LOCAL_SIMULATOR_ECS |Habilita ECS/Fargate | false |
-| AWS_LOCAL_SIMULATOR_DYNAMODB_PORT |Porta DynamoDB | 8000 |
-| AWS_LOCAL_SIMULATOR_S3_PORT |Porta S3 | 4566 |
-| AWS_LOCAL_SIMULATOR_SQS_PORT |Porta SQS | 9324 |
-| AWS_LOCAL_SIMULATOR_LAMBDA_PORT |Porta Lambda | 3001 |
-| AWS_LOCAL_SIMULATOR_COGNITO_PORT |Porta Cognito | 9229 |
-| AWS_LOCAL_SIMULATOR_APIGATEWAY_PORT |Porta API Gateway | 4567 |
-| AWS_LOCAL_SIMULATOR_ECS_PORT |Porta ECS | 8080 |
-| AWS_LOCAL_SIMULATOR_DATA |Diretório de dados | ./aws-local-simulator-data |
-| AWS_LOCAL_SIMULATOR_LOG |Nível de log | info |
-```
+| AWS_LOCAL_SIMULATOR_DYNAMODB | Habilita DynamoDB | true |
+| AWS_LOCAL_SIMULATOR_S3 | Habilita S3 | true |
+| AWS_LOCAL_SIMULATOR_SQS | Habilita SQS | true |
+| AWS_LOCAL_SIMULATOR_LAMBDA | Habilita Lambda | true |
+| AWS_LOCAL_SIMULATOR_COGNITO | Habilita Cognito | false |
+| AWS_LOCAL_SIMULATOR_APIGATEWAY | Habilita API Gateway | false |
+| AWS_LOCAL_SIMULATOR_STS | Habilita STS | true |
+| AWS_LOCAL_SIMULATOR_ECS | Habilita ECS/Fargate | false |
+| AWS_LOCAL_SIMULATOR_DYNAMODB_PORT | Porta DynamoDB | 8000 |
+| AWS_LOCAL_SIMULATOR_S3_PORT | Porta S3 | 4566 |
+| AWS_LOCAL_SIMULATOR_SQS_PORT | Porta SQS | 9324 |
+| AWS_LOCAL_SIMULATOR_LAMBDA_PORT | Porta Lambda | 3001 |
+| AWS_LOCAL_SIMULATOR_COGNITO_PORT | Porta Cognito | 9229 |
+| AWS_LOCAL_SIMULATOR_APIGATEWAY_PORT | Porta API Gateway | 4567 |
+| AWS_LOCAL_SIMULATOR_STS_PORT | Porta STS | 9326 |
+| AWS_LOCAL_SIMULATOR_ECS_PORT | Porta ECS | 8080 |
+| AWS_LOCAL_SIMULATOR_DATA | Diretório de dados | ./aws-local-simulator-data |
+| AWS_LOCAL_SIMULATOR_LOG | Nível de log | info |
+
+## 📝 Comandos CLI
 
-# 📝 Comandos CLI
 ```bash
-#### Iniciar simulador
+# Iniciar simulador
 npx aws-local-simulator start [configPath]
 
-#### Parar simulador
+# Parar simulador
 npx aws-local-simulator stop
 
-#### Reiniciar
+# Reiniciar
 npx aws-local-simulator restart
 
-#### Resetar dados
+# Resetar dados
 npx aws-local-simulator reset
 
-#### Status
+# Status
 npx aws-local-simulator status
 ```
 
-# 🔌 Endpoints
+## 🔌 Endpoints
+
 | Serviço | Endpoint | Admin |
 |---------|----------|-------|
-| DynamoDB | http://localhost:8000	| http://localhost:8000/__admin/tables |
-| S3 | http://localhost:4566	| http://localhost:4566/__admin/buckets |
-| SQS | http://localhost:9324	| http://localhost:9324/__admin/queues |
-| Lambda | http://localhost:3001	| http://localhost:3001/__admin/functions |
-| Cognito | http://localhost:9229	| http://localhost:9229/__admin/userpools |
-| API Gateway | http://localhost:4567	| http://localhost:4567/__admin/apis |
-| ECS | http://localhost:8080	| http://localhost:8080/__admin/clusters |
-
-🧪 Testando com AWS CLI
+| DynamoDB | http://localhost:8000 | http://localhost:8000/__admin/tables |
+| S3 | http://localhost:4566 | http://localhost:4566/__admin/buckets |
+| SQS | http://localhost:9324 | http://localhost:9324/__admin/queues |
+| Lambda | http://localhost:3001 | http://localhost:3001/__admin/functions |
+| Cognito | http://localhost:9229 | http://localhost:9229/__admin/userpools |
+| API Gateway | http://localhost:4567 | http://localhost:4567/__admin/apis |
+| STS | http://localhost:9326 | — |
+| ECS | http://localhost:8080 | http://localhost:8080/__admin/clusters |
+
+## 🧪 Testando com AWS CLI
+
 ```bash
 # DynamoDB
 aws dynamodb list-tables --endpoint-url http://localhost:8000
@@ -157,14 +167,59 @@ aws s3 ls --endpoint-url http://localhost:4566
 # SQS
 aws sqs list-queues --endpoint-url http://localhost:9324
 
+# Lambda — invocar por nome (não por path HTTP)
+aws lambda invoke \
+  --function-name my-function \
+  --payload '{"key":"value"}' \
+  --endpoint-url http://localhost:3001 \
+  output.json
+
 # Cognito
 aws cognito-idp list-user-pools --max-results 10 --endpoint-url http://localhost:9229
 
+# STS
+aws sts get-caller-identity --endpoint-url http://localhost:9326
+aws sts assume-role \
+  --role-arn "arn:aws:iam::123456789012:role/my-role" \
+  --role-session-name "my-session" \
+  --endpoint-url http://localhost:9326
+
 # API Gateway
 aws apigateway get-rest-apis --endpoint-url http://localhost:4567
 ```
 
-📁 Estrutura de Dados
+## ⚙️ Configuração de Lambdas
+
+Lambdas são registradas por **nome** e invocadas via API de invocação (igual à AWS real). O roteamento HTTP é feito pelo API Gateway.
+
+```json
+{
+  "lambdas": [
+    {
+      "name": "my-function",
+      "handler": "./src/handlers/my-function.js",
+      "env": {
+        "TABLE_NAME": "users-table",
+        "BUCKET_NAME": "my-bucket"
+      }
+    }
+  ]
+}
+```
+
+O handler deve exportar uma função padrão:
+
+```javascript
+exports.handler = async (event, context) => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: 'Hello from Lambda!' })
+  };
+};
+```
+
+## 📁 Estrutura de Dados
+
 Os dados são persistidos em:
 
 ```text
@@ -177,28 +232,26 @@ Os dados são persistidos em:
 └── ecs/
 ```
 
-🐛 Debug
-Para logs detalhados:
+## 🐛 Debug
 
-bash
+```bash
 AWS_LOCAL_SIMULATOR_LOG=verboso npx aws-local-simulator start
-🤝 Contribuindo
-Fork o projeto
-
-Crie sua feature branch (git checkout -b feature/AmazingFeature)
+```
 
-Commit suas mudanças (git commit -m 'Add some AmazingFeature')
+## 🤝 Contribuindo
 
-Push para a branch (git push origin feature/AmazingFeature)
+1. Fork o projeto
+2. Crie sua feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
+4. Push para a branch (`git push origin feature/AmazingFeature`)
+5. Abra um Pull Request
 
-Abra um Pull Request
+## 📄 Licença
 
-📄 Licença
 MIT © Luiz Gustavo Ribeiro
 
-⚠️ Limitações
-SNS e EventBridge em desenvolvimento
-
-WebSocket APIs em desenvolvimento
+## ⚠️ Limitações
 
-Para uso em desenvolvimento e testes apenas
+- SNS e EventBridge em desenvolvimento
+- WebSocket APIs em desenvolvimento
+- Para uso em desenvolvimento e testes apenas

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -109,6 +109,6 @@
       "optional": true
     }
   },
-  "buildDate": "2026-04-03T22:32:50.683Z",
+  "buildDate": "2026-04-04T03:21:21.370Z",
   "published": true
 }

package/src/config/config-loader.js

@@ -23,6 +23,7 @@ class ConfigLoader {
     if (configPath) {
       const userConfig = await this.loadUserConfig(configPath);
       config = this.mergeDeep(config, userConfig);
+      config._configPath = path.resolve(process.cwd(), configPath);
     } else {
       // Tenta encontrar arquivo de configuração padrão
       const possiblePaths = [
@@ -35,6 +36,7 @@ class ConfigLoader {
         if (fs.existsSync(possiblePath)) {
           const userConfig = await this.loadUserConfig(possiblePath);
           config = this.mergeDeep(config, userConfig);
+          config._configPath = possiblePath;
           logger.info(`✅ Configuração carregada de: ${possiblePath}`);
           break;
         }

package/src/config/default-config.js

@@ -14,6 +14,7 @@ module.exports = {
     ecs: false,
     cognito: false,
     apigateway: false,
+    sts: true,
   },
 
   // Portas padrão
@@ -27,6 +28,7 @@ module.exports = {
     ecs: 8080,
     cognito: 9229,
     apigateway: 4567,
+    sts: 9326,
   },
   apigateway: {
     defaultCors: {

package/src/server.js

@@ -17,6 +17,7 @@ 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) {
@@ -65,6 +66,7 @@ class Server {
   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: [] },
@@ -73,7 +75,7 @@ class Server {
       { name: "eventbridge", class: EventBridgeService, depends: [] },
       { name: "cognito", class: CognitoService, depends: [] },
       { name: "ecs", class: ECSService, depends: [] },
-      { name: "apigateway", class: APIGatewayService, depends: [] },
+      { name: "apigateway", class: APIGatewayService, depends: ["lambda"] },
     ];
 
     for (const serviceDef of serviceOrder) {

package/src/services/apigateway/index.js

@@ -7,24 +7,26 @@ 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();
     

package/src/services/apigateway/server.js

@@ -35,10 +35,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/cognito/server.js

@@ -16,7 +16,19 @@ class CognitoServer {
   }
 
   setupMiddlewares() {
-    this.app.use(express.json());
+    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();
+    });
     
     if (logger.currentLogLevel === 'verboso') {
       this.app.use((req, res, next) => {
@@ -48,12 +60,13 @@ class CognitoServer {
     // User Pool operations
     this.app.post('/', async (req, res) => {
       const target = req.headers['x-amz-target'];
+      logger.info(`Cognito incoming: target=${target} body=${JSON.stringify(req.body)}`);
       if (!target) {
         return res.status(400).json({ error: 'Missing X-Amz-Target header' });
       }
 
       try {
-        const result = await this.handleRequest(target, req.body);
+        const result = await this.handleRequest(target, req.body || {});
         res.json(result);
       } catch (error) {
         logger.error('Cognito Error:', error);
@@ -84,20 +97,46 @@ class CognitoServer {
       case 'DeleteUserPool':
         return this.simulator.deleteUserPool(params);
       
+      case 'ListUsers':
+        return this.simulator.listUsers(params);
       // User Pool Client Management
       case 'CreateUserPoolClient':
         return this.simulator.createUserPoolClient(params);
+      case 'ListUserPoolClients':
+        return this.simulator.listUserPoolClients(params);
+      case 'DescribeUserPoolClient':
+        return this.simulator.describeUserPoolClient(params);
+      case 'DeleteUserPoolClient':
+        return this.simulator.deleteUserPoolClient(params);
       
       // User Operations
       case 'SignUp':
         return this.simulator.signUp(params);
       case 'ConfirmSignUp':
         return this.simulator.confirmSignUp(params);
+      case 'ForgotPassword':
+        return this.simulator.forgotPassword(params);
+      case 'ConfirmForgotPassword':
+        return this.simulator.confirmForgotPassword(params);
+      case 'ChangePassword':
+        return this.simulator.changePassword(params);
       case 'InitiateAuth':
         return this.simulator.initiateAuth(params);
+      case 'RespondToAuthChallenge':
+        return this.simulator.respondToAuthChallenge(params);
       case 'GetToken':
         return this.simulator.getToken(params);
-      
+      case 'GlobalSignOut':
+        return this.simulator.globalSignOut(params);
+      case 'RevokeToken':
+        return this.simulator.revokeToken(params);
+      case 'GetUser':
+        return this.simulator.getUser(params);
+      case 'UpdateUserAttributes':
+        return this.simulator.updateUserAttributes(params);
+      case 'DeleteUser':
+        return this.simulator.deleteUser(params);
+
       // Admin Operations
       case 'AdminGetUser':
         return this.simulator.adminGetUser(params);
@@ -107,6 +146,18 @@ class CognitoServer {
         return this.simulator.adminSetUserPassword(params);
       case 'AdminDeleteUser':
         return this.simulator.adminDeleteUser(params);
+      case 'AdminDisableUser':
+        return this.simulator.adminDisableUser(params);
+      case 'AdminEnableUser':
+        return this.simulator.adminEnableUser(params);
+      case 'AdminResetUserPassword':
+        return this.simulator.adminResetUserPassword(params);
+      case 'AdminInitiateAuth':
+        return this.simulator.initiateAuth(params);
+      case 'AdminListGroupsForUser':
+        return this.simulator.adminListGroupsForUser(params);
+      case 'AdminUserGlobalSignOut':
+        return this.simulator.adminUserGlobalSignOut(params);
       
       // Identity Pool Operations
       case 'CreateIdentityPool':