@gugananuvem/aws-local-simulator 1.0.12 → 1.0.14

package/README.md

@@ -13,13 +13,22 @@ 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 (invocação por nome) |
+| Lambda | ✅ | 3001 | Funções serverless |
 | Cognito | ✅ | 9229 | Autenticação e autorização |
 | API Gateway | ✅ | 4567 | APIs REST e HTTP |
-| STS | ✅ | 9326 | Credenciais temporárias (AssumeRole, GetCallerIdentity) |
+| STS | ✅ | 9326 | Credenciais temporárias |
+| SNS | ✅ | 9911 | Notificações pub/sub |
+| EventBridge | ✅ | 4010 | Barramento de eventos |
+| KMS | ✅ | 4000 | Gerenciamento de chaves |
+| Secrets Manager | ✅ | 4001 | Gerenciamento de segredos |
+| Parameter Store | ✅ | 4002 | Armazenamento de parâmetros |
+| CloudWatch | ✅ | 4011 | Logs, métricas e alarmes |
+| CloudTrail | ✅ | 4012 | Auditoria de API calls |
+| AWS Config | ✅ | 4013 | Conformidade e configuração |
+| CloudFormation | ✅ | 4580 | Infraestrutura como código |
+| Athena | ✅ | 4599 | Consultas SQL em dados no S3 |
+| X-Ray | ✅ | 4015 | Rastreamento distribuído |
 | ECS/Fargate | 🚧 | 8080 | Orquestração de containers (em desenvolvimento) |
-| SNS | 🚧 | 9911 | Notificações (em desenvolvimento) |
-| EventBridge | 🚧 | 4010 | Barramento de eventos (em desenvolvimento) |
 
 ## 📦 Instalação
 
@@ -40,7 +49,18 @@ npm install --save-dev aws-local-simulator
     "lambda": true,
     "cognito": true,
     "apigateway": true,
-    "sts": true
+    "sts": true,
+    "sns": true,
+    "eventbridge": true,
+    "kms": true,
+    "secret-manager": true,
+    "parameter-store": true,
+    "cloudwatch": true,
+    "cloudtrail": true,
+    "cloudformation": true,
+    "xray": true,
+    "config": true,
+    "athena": true
   },
   "lambdas": [
     {
@@ -111,6 +131,17 @@ await dynamoDB.send(new PutCommand({
 | 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_SNS | Habilita SNS | false |
+| AWS_LOCAL_SIMULATOR_EVENTBRIDGE | Habilita EventBridge | false |
+| AWS_LOCAL_SIMULATOR_KMS | Habilita KMS | false |
+| AWS_LOCAL_SIMULATOR_SECRET_MANAGER | Habilita Secrets Manager | false |
+| AWS_LOCAL_SIMULATOR_PARAMETER_STORE | Habilita Parameter Store | false |
+| AWS_LOCAL_SIMULATOR_CLOUDWATCH | Habilita CloudWatch | false |
+| AWS_LOCAL_SIMULATOR_CLOUDTRAIL | Habilita CloudTrail | false |
+| AWS_LOCAL_SIMULATOR_CLOUDFORMATION | Habilita CloudFormation | false |
+| AWS_LOCAL_SIMULATOR_ATHENA | Habilita Athena | false |
+| AWS_LOCAL_SIMULATOR_XRAY | Habilita X-Ray | false |
+| AWS_LOCAL_SIMULATOR_CONFIG | Habilita AWS Config | 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 |
@@ -119,6 +150,17 @@ await dynamoDB.send(new PutCommand({
 | 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_SNS_PORT | Porta SNS | 9911 |
+| AWS_LOCAL_SIMULATOR_EVENTBRIDGE_PORT | Porta EventBridge | 4010 |
+| AWS_LOCAL_SIMULATOR_KMS_PORT | Porta KMS | 4000 |
+| AWS_LOCAL_SIMULATOR_SECRET_MANAGER_PORT | Porta Secrets Manager | 4001 |
+| AWS_LOCAL_SIMULATOR_PARAMETER_STORE_PORT | Porta Parameter Store | 4002 |
+| AWS_LOCAL_SIMULATOR_CLOUDWATCH_PORT | Porta CloudWatch | 4011 |
+| AWS_LOCAL_SIMULATOR_CLOUDTRAIL_PORT | Porta CloudTrail | 4012 |
+| AWS_LOCAL_SIMULATOR_CONFIG_PORT | Porta AWS Config | 4013 |
+| AWS_LOCAL_SIMULATOR_XRAY_PORT | Porta X-Ray | 4015 |
+| AWS_LOCAL_SIMULATOR_CLOUDFORMATION_PORT | Porta CloudFormation | 4580 |
+| AWS_LOCAL_SIMULATOR_ATHENA_PORT | Porta Athena | 4599 |
 | 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 |
@@ -153,6 +195,17 @@ npx aws-local-simulator status
 | Cognito | http://localhost:9229 | http://localhost:9229/__admin/userpools |
 | API Gateway | http://localhost:4567 | http://localhost:4567/__admin/apis |
 | STS | http://localhost:9326 | — |
+| SNS | http://localhost:9911 | http://localhost:9911/__admin/health |
+| EventBridge | http://localhost:4010 | — |
+| KMS | http://localhost:4000 | — |
+| Secrets Manager | http://localhost:4001 | — |
+| Parameter Store | http://localhost:4002 | — |
+| CloudWatch | http://localhost:4011 | — |
+| CloudTrail | http://localhost:4012 | — |
+| AWS Config | http://localhost:4013 | — |
+| X-Ray | http://localhost:4015 | — |
+| 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 |
 
 ## 🧪 Testando com AWS CLI
@@ -167,7 +220,7 @@ 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)
+# Lambda
 aws lambda invoke \
   --function-name my-function \
   --payload '{"key":"value"}' \
@@ -184,8 +237,126 @@ aws sts assume-role \
   --role-session-name "my-session" \
   --endpoint-url http://localhost:9326
 
+# SNS
+aws sns list-topics --endpoint-url http://localhost:9911
+
+# EventBridge
+aws events list-event-buses --endpoint-url http://localhost:4010
+
+# KMS
+aws kms list-keys --endpoint-url http://localhost:4000
+
+# Secrets Manager
+aws secretsmanager list-secrets --endpoint-url http://localhost:4001
+
+# Criar secret
+aws secretsmanager create-secret \
+  --name "local/app/db-credentials" \
+  --description "Credenciais do banco" \
+  --secret-string '{"username":"admin","password":"secret123"}' \
+  --endpoint-url http://localhost:4001
+
+# Ler secret
+aws secretsmanager get-secret-value \
+  --secret-id "local/app/db-credentials" \
+  --endpoint-url http://localhost:4001
+
+# Parameter Store
+aws ssm describe-parameters --endpoint-url http://localhost:4002
+
+# Criar parâmetro String
+aws ssm put-parameter \
+  --name "/local/app/config" \
+  --value '{"timeout":30,"maxRetries":3}' \
+  --type String \
+  --endpoint-url http://localhost:4002
+
+# Criar parâmetro SecureString
+aws ssm put-parameter \
+  --name "/local/app/api-key" \
+  --value "my-secret-api-key" \
+  --type SecureString \
+  --endpoint-url http://localhost:4002
+
+# Ler parâmetro
+aws ssm get-parameter \
+  --name "/local/app/config" \
+  --endpoint-url http://localhost:4002
+
+# CloudWatch
+aws cloudwatch list-metrics --endpoint-url http://localhost:4011
+aws logs describe-log-groups --endpoint-url http://localhost:4011
+
+# CloudTrail
+aws cloudtrail describe-trails --endpoint-url http://localhost:4012
+
+# CloudFormation
+aws cloudformation list-stacks --endpoint-url http://localhost:4580
+
+# X-Ray
+aws xray get-trace-summaries \
+  --start-time $(date -d '1 hour ago' +%s) \
+  --end-time $(date +%s) \
+  --endpoint-url http://localhost:4015
+
+# AWS Config
+aws configservice describe-configuration-recorders --endpoint-url http://localhost:4013
+
 # API Gateway
 aws apigateway get-rest-apis --endpoint-url http://localhost:4567
+
+# Cloudformation
+aws cloudformation create-stack \
+  --stack-name test-stack \
+  --template-body file://templates/test-stack.yaml \
+  --parameters \
+    ParameterKey=Environment,ParameterValue=local \
+    ParameterKey=BucketName,ParameterValue=meu-bucket \
+    ParameterKey=QueueName,ParameterValue=minha-fila \
+    ParameterKey=TableName,ParameterValue=minha-tabela \
+  --endpoint-url http://localhost:4580
+
+# Ver Cloudformation resultado 
+aws cloudformation describe-stacks \
+  --stack-name test-stack \
+  --endpoint-url http://localhost:4580  
+
+# Athena
+# Criar workgroup
+aws athena create-work-group \
+  --name my-workgroup \
+  --configuration ResultConfiguration={OutputLocation=s3://meu-bucket/athena-results/} \
+  --endpoint-url http://localhost:4599
+
+# Listar workgroups
+aws athena list-work-groups --endpoint-url http://localhost:4599
+
+# Executar query
+aws athena start-query-execution \
+  --query-string "SELECT * FROM my_table LIMIT 10" \
+  --query-execution-context Database=default \
+  --result-configuration OutputLocation=s3://meu-bucket/athena-results/ \
+  --endpoint-url http://localhost:4599
+
+# Verificar status da query
+aws athena get-query-execution \
+  --query-execution-id <id-retornado> \
+  --endpoint-url http://localhost:4599
+
+# Buscar resultados
+aws athena get-query-results \
+  --query-execution-id <id-retornado> \
+  --endpoint-url http://localhost:4599
+
+# Criar named query
+aws athena create-named-query \
+  --name "my-saved-query" \
+  --database default \
+  --query-string "SELECT id, value FROM my_table WHERE status = 'active'" \
+  --endpoint-url http://localhost:4599
+
+# Listar named queries
+aws athena list-named-queries --endpoint-url http://localhost:4599
 ```
 
 ## ⚙️ Configuração de Lambdas
@@ -196,8 +367,8 @@ Lambdas são registradas por **nome** e invocadas via API de invocação (igual
 {
   "lambdas": [
     {
-      "name": "my-function",
-      "handler": "./src/handlers/my-function.js",
+      "name": "my-user-function",
+      "handler": "./src/handlers/my-user-function.js",
       "env": {
         "TABLE_NAME": "users-table",
         "BUCKET_NAME": "my-bucket"
@@ -207,6 +378,50 @@ Lambdas são registradas por **nome** e invocadas via API de invocação (igual
 }
 ```
 
+## ⚙️ Configuração API GATEWAY
+
+O valor do **lambdaName** deve igual ao nome Lambda que está registrada com o valor **name**. Ex: "my-user-function".
+
+```json
+{
+  "apigateway": {
+    "apis": [
+      {
+        "name": "Users API",
+        "description": "API para gerenciamento de usuários",
+        "endpoints": [
+          {
+            "path": "/user",
+            "method": "GET",
+            "lambdaName": "my-user-function",
+            "integrationType": "lambda"
+          },
+          {
+            "path": "/user",
+            "method": "POST",
+            "lambdaName": "my-user-function",
+            "integrationType": "lambda"
+          },
+          {
+            "path": "/user/{id}",
+            "method": "GET",
+            "lambdaName": "my-user-function",
+            "integrationType": "lambda"
+          },
+          {
+            "path": "/user/{id}",
+            "method": "DELETE",
+            "lambdaName": "my-user-function",
+            "integrationType": "lambda"
+          }
+        ]
+      }
+    ]
+  },
+
+}
+```
+
 O handler deve exportar uma função padrão:
 
 ```javascript
@@ -229,13 +444,22 @@ Os dados são persistidos em:
 ├── sqs/
 ├── cognito/
 ├── apigateway/
-└── ecs/
+├── ecs/
+├── kms/
+├── secret-manager/
+├── parameter-store/
+├── cloudwatch/
+├── cloudtrail/
+├── cloudformation/
+├── athena/
+├── xray/
+└── config/
 ```
 
 ## 🐛 Debug
 
 ```bash
-AWS_LOCAL_SIMULATOR_LOG=verboso npx aws-local-simulator start
+AWS_LOCAL_SIMULATOR_LOG=verbose npx aws-local-simulator start
 ```
 
 ## 🤝 Contribuindo
@@ -252,6 +476,6 @@ MIT © Luiz Gustavo Ribeiro
 
 ## ⚠️ Limitações
 
-- SNS e EventBridge em desenvolvimento
+- ECS/Fargate 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.12",
+  "version": "1.0.14",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -45,7 +45,17 @@
     "lambda",
     "cognito",
     "apigateway",
+    "kms",
+    "config",
+    "parameter-store",
+    "secret-manager",
+    "cloudformation",
+    "eventbridge",
+    "sns",
     "ecs",
+    "sts",
+    "cloudtrail",
+    "cloudwatch",
     "development",
     "testing"
   ],
@@ -109,6 +119,6 @@
       "optional": true
     }
   },
-  "buildDate": "2026-04-04T03:21:21.370Z",
+  "buildDate": "2026-04-05T12:32:46.437Z",
   "published": true
 }

package/src/config/default-config.js

@@ -29,6 +29,7 @@ module.exports = {
     cognito: 9229,
     apigateway: 4567,
     sts: 9326,
+    athena: 4599,
   },
   apigateway: {
     defaultCors: {

package/src/index.js

@@ -11,8 +11,16 @@ 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 { SNSService } = require('./services/sns');
+const { EventBridgeService } = require('./services/eventbridge');
+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');
 
 // Exporta utilitários
 const LocalStore = require('./utils/local-store');
@@ -122,6 +130,14 @@ module.exports = {
   LambdaService,
   SNSService,
   EventBridgeService,
+  CloudWatchService,
+  CloudTrailService,
+  KMSService,
+  CloudFormationService,
+  XRayService,
+  SecretManagerService,
+  ParameterStoreService,
+  ConfigService,
   LocalStore,
   HandlerLoader,
   RouteRegistry

package/src/server.js

@@ -12,12 +12,21 @@ 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 { 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) {
@@ -64,24 +73,31 @@ 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: [] },
-      { 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"] },
+      { 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"] },
+      { 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 {
-          // Resolve dependências
           const dependencies = {};
           for (const dep of serviceDef.depends) {
             dependencies[dep] = this.servicesMap.get(dep);
@@ -96,29 +112,17 @@ class Server {
           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
-          }
+          if (serviceDef.name === "lambda") throw error;
         }
       }
     }
 
-    /*
-    // 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");
+    // Injeta dependências cross-service nos serviços que suportam
+    for (const service of this.services) {
+      if (typeof service.injectDependencies === "function") {
+        service.injectDependencies(this);
+      }
     }
-    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() {

package/src/services/apigateway/index.js

@@ -33,6 +33,11 @@ class APIGatewayService {
     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();

package/src/services/apigateway/server.js

@@ -19,6 +19,26 @@ class APIGatewayServer {
   setupMiddlewares() {
     this.app.use(express.json({ limit: '10mb' }));
     this.app.use(express.urlencoded({ extended: true, limit: '10mb' }));
+    // Parse bodies with AWS content types (e.g. application/x-amz-json-1.1)
+    this.app.use((req, res, next) => {
+      const ct = req.headers['content-type'] || ''; 
+      if ((req.body && JSON.stringify(req.body) == "{}") && ct.includes('application/x-amz-json')) {
+        let data = "";
+        req.on("data", (chunk) => {
+          data += chunk;
+        });
+        req.on("end", () => {
+          try {
+            req.body = JSON.parse(data);
+          } catch (error) {
+            req.body = {};
+          }
+          next();
+        });
+      } else {
+        next();
+      }      
+    });
     this.app.use(cors());
     
     if (logger.currentLogLevel === 'verboso') {

package/src/services/apigateway/simulator.js

@@ -9,14 +9,15 @@ const logger = require('../../utils/logger');
 const LocalStore = require('../../utils/local-store');
 const path = require('path');
 const { URLPattern } = require('urlpattern-polyfill');
+const { CloudTrailAudit } = require('../../utils/cloudtrail-audit');
 
 class APIGatewaySimulator {
   constructor(config) {
     this.config = config;
     this.dataDir = path.join(process.env.AWS_LOCAL_SIMULATOR_DATA_DIR, 'apigateway');
     this.store = new LocalStore(this.dataDir);
-    this.apis = new Map();           // REST/HTTP APIs
-    this.websocketApis = new Map();  // WebSocket APIs
+    this.apis = new Map();
+    this.websocketApis = new Map();
     this.deployments = new Map();
     this.stages = new Map();
     this.resources = new Map();
@@ -26,6 +27,7 @@ class APIGatewaySimulator {
     this.usagePlans = new Map();
     this.apiKeys = new Map();
     this.domainNames = new Map();
+    this.audit = new CloudTrailAudit('execute-api.amazonaws.com');
   }
 
   async initialize() {
@@ -734,7 +736,15 @@ class APIGatewaySimulator {
       response.headers = { ...response.headers, ...integrationResponse.responseParameters };
       response.body = this.applyResponseTemplate(integrationResponse, response.body);
     }
-    
+
+    this.audit.record({
+      eventName: 'Invoke',
+      readOnly: method === 'GET' || method === 'HEAD',
+      isDataEvent: true,
+      resources: [{ ARN: `arn:aws:execute-api:local:000000000000:${apiId}/${stageName}/${method}${path}`, type: 'AWS::APIGateway::Stage' }],
+      requestParameters: { apiId, stageName, method, path },
+    });
+
     return response;
   }
 

package/src/services/athena/index.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const http = require('http');
+const path = require('path');
+const { AthenaSimulator } = require('./simulator');
+const { createAthenaServer } = require('./server');
+const LocalStore = require('../../utils/local-store');
+
+class AthenaService {
+  constructor(config) {
+    this.config = config;
+    this.logger = require('../../utils/logger');
+    this.name = 'athena';
+    this.port = config?.ports?.athena || 4599;
+    this.store = null;
+    this.simulator = null;
+    this._server = null;
+    this.isRunning = false;
+  }
+
+  async initialize() {
+    this.logger.debug(`Inicializando Athena Service na porta ${this.port}...`);
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+    this.store = new LocalStore(path.join(dataDir, 'athena'));
+    this.simulator = new AthenaSimulator(this.config, this.store, this.logger);
+    await this.simulator.initialize();
+    this.app = createAthenaServer(this.simulator, this.logger);
+    this.logger.debug('Athena Service inicializado');
+  }
+
+  injectDependencies(server) {
+    const ct = server.getService('cloudtrail');
+    if (ct?.simulator) this.simulator.audit.setTrail(ct.simulator);
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    return new Promise((resolve, reject) => {
+      this._server = http.createServer(this.app);
+      this._server.listen(this.port, () => {
+        this.isRunning = true;
+        this.logger.info(`🔍 Athena rodando em http://localhost:${this.port}`);
+        resolve();
+      });
+      this._server.on('error', reject);
+    });
+  }
+
+  async stop() {
+    if (!this.isRunning || !this._server) return;
+    return new Promise((resolve) => {
+      this._server.close(() => {
+        this.isRunning = false;
+        resolve();
+      });
+    });
+  }
+
+  async reset() {
+    await this.simulator.reset();
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      ...this.simulator?.getStats(),
+    };
+  }
+
+  getSimulator() { return this.simulator; }
+}
+
+module.exports = { AthenaService };