@gugananuvem/aws-local-simulator 1.0.14 → 1.0.16

package/src/services/dynamodb/server.js

@@ -3,6 +3,7 @@
  */
 
 const express = require('express');
+const cors = require('cors');
 const DynamoDBSimulator = require('./simulator');
 const logger = require('../../utils/logger');
 
@@ -17,6 +18,7 @@ class DynamoDBServer {
   }
 
   setupMiddlewares() {
+    this.app.use(cors());
     this.app.use(express.json({
       type: 'application/x-amz-json-1.0'
     }));

package/src/services/ecs/server.js

@@ -3,6 +3,7 @@
  */
 
 const express = require('express');
+const cors = require('cors');
 const logger = require('../../utils/logger');
 
 class ECSServer {
@@ -16,6 +17,7 @@ class ECSServer {
   }
 
   setupMiddlewares() {
+    this.app.use(cors());
     this.app.use(express.json());
     
     if (logger.currentLogLevel === 'verboso') {

package/src/services/eventbridge/server.js

@@ -18,8 +18,8 @@ const cors = require('cors');
 function createEventBridgeServer(simulator, config, logger) {
   const app = express();
 
-  if (config.cors?.enabled) {
-    app.use(cors({ origin: config.cors.origin || '*' }));
+  if (config.cors?.enabled !== false) {
+    app.use(cors({ origin: config.cors?.origin || '*' }));
   }
 
   app.use(express.json({ limit: '10mb' }));

package/src/services/lambda/simulator.js

@@ -17,6 +17,12 @@ class LambdaSimulator {
   async initialize() {
     logger.debug("Inicializando Lambda Simulator...");
 
+    // Build global lambda defaults from config.global
+    const globalDefaults = this.config.global || {};
+    this.globalEnv = globalDefaults.env || {};
+    this.globalTimeout = globalDefaults.timeout || null;
+    this.globalMemorySize = globalDefaults.memorySize || null;
+
     if (this.config.lambdas && this.config.lambdas.length > 0) {
       for (const lambdaConfig of this.config.lambdas) {
         await this.registerLambda(lambdaConfig);
@@ -28,13 +34,22 @@ class LambdaSimulator {
 
   async registerLambda(lambdaConfig) {
     try {
-      const { name, handler: handlerPath, env = {}, type = "auto" } = lambdaConfig;
+      const { name, handler: handlerPath, type = "auto" } = lambdaConfig;
 
       if (!name) {
         logger.warn(`Lambda sem nome ignorada: ${JSON.stringify(lambdaConfig)}`);
         return;
       }
 
+      // Merge: global env as base, lambda-specific env overrides
+      const env = {
+        ...(this.globalEnv || {}),
+        ...(lambdaConfig.env || {}),
+      };
+
+      const timeout = lambdaConfig.timeout ?? this.globalTimeout ?? 30;
+      const memorySize = lambdaConfig.memorySize ?? this.globalMemorySize ?? 128;
+
       const handler = await HandlerLoader.load(handlerPath, type);
       if (handler != undefined) {
         this.lambdas.set(name, {
@@ -43,6 +58,8 @@ class LambdaSimulator {
           handlerPath,
           handlerName: handler.name || "anonymous",
           env,
+          timeout,
+          memorySize,
           type,
           registeredAt: new Date().toISOString(),
         });

package/src/services/s3/server.js

@@ -3,6 +3,7 @@
  */
 
 const express = require('express');
+const cors = require('cors');
 const S3Simulator = require('./simulator');
 const logger = require('../../utils/logger');
 
@@ -17,6 +18,7 @@ class S3Server {
   }
 
   setupMiddlewares() {
+    this.app.use(cors());
     // Captura raw body como Buffer para qualquer content-type
     this.app.use(express.raw({ type: () => true, limit: '100mb' }));
     this.app.use(express.text({ limit: '100mb' }));
@@ -43,6 +45,13 @@ class S3Server {
   }
 
   setupRoutes() {
+    // Admin endpoints devem vir antes das rotas S3 para evitar conflito com /:bucket
+    this.setupAdminRoutes();
+
+    // Website static serving: GET /website/{bucket}/[path]
+    this.app.get('/website/:bucket', (req, res) => this._serveWebsite(req, res, ''));
+    this.app.get('/website/:bucket/*', (req, res) => this._serveWebsite(req, res, req.params[0]));
+
     // Listar buckets
     this.app.get('/', (req, res) => {
       const buckets = this.simulator.listBuckets();
@@ -52,6 +61,15 @@ class S3Server {
     
     // Criar bucket
     this.app.put('/:bucket', (req, res) => {
+      if (req.query.website !== undefined) {
+        let config = {};
+        try { config = JSON.parse(req.body?.toString() || '{}'); } catch (_) {}
+        const result = this.simulator.putWebsiteConfig(req.params.bucket, config);
+        if (result.error) {
+          return res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+        }
+        return res.status(200).send();
+      }
       const result = this.simulator.createBucket(req.params.bucket);
       if (result.error) {
         res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
@@ -62,6 +80,13 @@ class S3Server {
     
     // Deletar bucket
     this.app.delete('/:bucket', (req, res) => {
+      if (req.query.website !== undefined) {
+        const result = this.simulator.deleteWebsiteConfig(req.params.bucket);
+        if (result.error) {
+          return res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+        }
+        return res.status(204).send();
+      }
       const result = this.simulator.deleteBucket(req.params.bucket);
       if (result.error) {
         res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
@@ -153,8 +178,15 @@ class S3Server {
       }
     });
     
-    // List objects
+    // Website config
     this.app.get('/:bucket', (req, res) => {
+      if (req.query.website !== undefined) {
+        const result = this.simulator.getWebsiteConfig(req.params.bucket);
+        if (result.error) {
+          return res.status(result.status).send(this.simulator.generateErrorResponse(result.error.code, result.error.message));
+        }
+        return res.set('Content-Type', 'application/xml').send(this._generateWebsiteConfigXml(result.websiteConfiguration));
+      }
       const bucket = req.params.bucket;
       const prefix = req.query.prefix || '';
       const delimiter = req.query.delimiter;
@@ -176,7 +208,7 @@ class S3Server {
     });
     
     // Admin endpoints
-    this.setupAdminRoutes();
+    // (já registrados no início de setupRoutes)
   }
 
   setupAdminRoutes() {
@@ -213,6 +245,58 @@ class S3Server {
     });
   }
 
+  _serveWebsite(req, res, keyPath) {
+    const bucketName = req.params.bucket;
+    const bucket = this.simulator.getBucket(bucketName);
+
+    if (!bucket) {
+      return res.status(404).send('<html><body><h1>404 - Bucket not found</h1></body></html>');
+    }
+
+    if (!bucket.website) {
+      return res.status(403).send('<html><body><h1>403 - This bucket does not have static website hosting enabled</h1></body></html>');
+    }
+
+    const websiteConfig = bucket.websiteConfiguration || {};
+    const indexDoc = websiteConfig.IndexDocument?.Suffix || 'index.html';
+    const errorDoc = websiteConfig.ErrorDocument?.Key   || 'error.html';
+
+    // Resolve a chave: path vazio ou terminando em '/' serve o indexDocument
+    let key = keyPath || '';
+    if (!key || key.endsWith('/')) {
+      key = key + indexDoc;
+    }
+
+    let result = this.simulator.getObject(bucketName, key, req.headers);
+
+    // Se não encontrou e não tem extensão, tenta com indexDoc dentro do path
+    if (result.error && !key.includes('.')) {
+      result = this.simulator.getObject(bucketName, key + '/' + indexDoc, req.headers);
+    }
+
+    if (result.error) {
+      const errorResult = this.simulator.getObject(bucketName, errorDoc, req.headers);
+      if (!errorResult.error) {
+        res.status(404).set('Content-Type', errorResult.contentType || 'text/html');
+        return res.send(errorResult.content);
+      }
+      return res.status(404).send('<html><body><h1>404 - Not Found</h1></body></html>');
+    }
+
+    res.set('Content-Type', result.contentType || 'text/html');
+    res.set('ETag', `"${result.etag}"`);
+    res.set('Last-Modified', result.lastModified);
+    res.send(result.content);
+  }
+
+  _generateWebsiteConfigXml(config) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<WebsiteConfiguration>
+  <IndexDocument><Suffix>${config.IndexDocument?.Suffix || 'index.html'}</Suffix></IndexDocument>
+  <ErrorDocument><Key>${config.ErrorDocument?.Key || 'error.html'}</Key></ErrorDocument>
+</WebsiteConfiguration>`;
+  }
+
   start() {
     return new Promise((resolve) => {
       this.server = this.app.listen(this.port, () => {

package/src/services/s3/simulator.js

@@ -25,12 +25,6 @@ class S3Simulator {
   }
 
   loadBuckets() {
-    if (this.config.s3?.buckets) {
-      for (const bucketName of this.config.s3.buckets) {
-        this.createBucket(bucketName);
-      }
-    }
-
     const savedBuckets = this.store.read("__buckets__");
     if (savedBuckets && typeof savedBuckets === "object" && !Array.isArray(savedBuckets)) {
       for (const [name, data] of Object.entries(savedBuckets)) {
@@ -48,6 +42,9 @@ class S3Simulator {
           }
           this.buckets.set(name, {
             name,
+            region: data.region || "us-east-1",
+            website: !!(data.websiteConfiguration),
+            websiteConfiguration: data.websiteConfiguration || null,
             creationDate: new Date(data.creationDate),
             objects,
             objectCount: data.objectCount || 0,
@@ -56,6 +53,20 @@ class S3Simulator {
         }
       }
     }
+
+    // Cria buckets definidos na config que ainda não existem
+    if (this.config.s3?.buckets) {
+      for (const bucketDef of this.config.s3.buckets) {
+        // suporta string simples ou objeto { name, region, websiteConfiguration }
+        const bucketName     = typeof bucketDef === "string" ? bucketDef : bucketDef.name;
+        const region         = typeof bucketDef === "object" ? (bucketDef.region || "us-east-1") : "us-east-1";
+        const websiteConfig  = typeof bucketDef === "object" ? (bucketDef.websiteConfiguration || null) : null;
+
+        if (!this.buckets.has(bucketName)) {
+          this.createBucket(bucketName, { region, websiteConfiguration: websiteConfig });
+        }
+      }
+    }
   }
 
   // ─── Helpers de conteúdo em arquivo ───────────────────────────────────────
@@ -91,7 +102,7 @@ class S3Simulator {
 
   // ─── Buckets ──────────────────────────────────────────────────────────────
 
-  createBucket(bucketName) {
+  createBucket(bucketName, options = {}) {
     if (!this.isValidBucketName(bucketName)) {
       return { error: { code: "InvalidBucketName", message: "Bucket name is invalid" }, status: 400 };
     }
@@ -100,8 +111,18 @@ class S3Simulator {
       return { error: { code: "BucketAlreadyExists", message: "Bucket already exists" }, status: 409 };
     }
 
+    const { region = "us-east-1", websiteConfiguration = null } = options;
+
     const bucket = {
       name: bucketName,
+      region,
+      website: !!websiteConfiguration,
+      websiteConfiguration: websiteConfiguration
+        ? {
+            IndexDocument: { Suffix: websiteConfiguration.IndexDocument?.Suffix || "index.html" },
+            ErrorDocument: { Key: websiteConfiguration.ErrorDocument?.Key || "error.html" },
+          }
+        : null,
       creationDate: new Date(),
       objects: new Map(),
       objectCount: 0,
@@ -110,7 +131,7 @@ class S3Simulator {
 
     this.buckets.set(bucketName, bucket);
     this.persistBuckets();
-    logger.debug(`✅ Bucket S3 criado: ${bucketName}`);
+    logger.debug(`✅ Bucket S3 criado: ${bucketName} (region: ${region}${websiteConfiguration ? ", website: enabled" : ""})`);
     this.audit.record({ eventName: "CreateBucket", readOnly: false, resources: [{ ARN: `arn:aws:s3:::${bucketName}`, type: "AWS::S3::Bucket" }], requestParameters: { bucketName } });
     return { bucket };
   }
@@ -141,6 +162,8 @@ class S3Simulator {
   getBucketsInfo() {
     return Array.from(this.buckets.values()).map((bucket) => ({
       name: bucket.name,
+      region: bucket.region,
+      website: bucket.website,
       creationDate: bucket.creationDate,
       objectCount: bucket.objectCount,
       totalSize: bucket.totalSize,
@@ -154,6 +177,9 @@ class S3Simulator {
     }
     return {
       name: bucket.name,
+      region: bucket.region,
+      website: bucket.website,
+      websiteConfiguration: bucket.websiteConfiguration,
       creationDate: bucket.creationDate,
       objectCount: bucket.objectCount,
       totalSize: bucket.totalSize,
@@ -371,6 +397,46 @@ class S3Simulator {
     }));
   }
 
+  // ─── Website Config ───────────────────────────────────────────────────────
+
+  getWebsiteConfig(bucketName) {
+    const bucket = this.buckets.get(bucketName);
+    if (!bucket) {
+      return { error: { code: "NoSuchBucket", message: "Bucket does not exist" }, status: 404 };
+    }
+    if (!bucket.websiteConfiguration) {
+      return { error: { code: "NoSuchWebsiteConfiguration", message: "The specified bucket does not have a website configuration" }, status: 404 };
+    }
+    return { websiteConfiguration: bucket.websiteConfiguration };
+  }
+
+  putWebsiteConfig(bucketName, config) {
+    const bucket = this.buckets.get(bucketName);
+    if (!bucket) {
+      return { error: { code: "NoSuchBucket", message: "Bucket does not exist" }, status: 404 };
+    }
+    bucket.website = true;
+    bucket.websiteConfiguration = {
+      IndexDocument: { Suffix: config.IndexDocument?.Suffix || "index.html" },
+      ErrorDocument: { Key: config.ErrorDocument?.Key || "error.html" },
+    };
+    this.persistBuckets();
+    logger.debug(`🌐 Website config atualizada: ${bucketName}`);
+    return { success: true };
+  }
+
+  deleteWebsiteConfig(bucketName) {
+    const bucket = this.buckets.get(bucketName);
+    if (!bucket) {
+      return { error: { code: "NoSuchBucket", message: "Bucket does not exist" }, status: 404 };
+    }
+    bucket.website = false;
+    bucket.websiteConfiguration = null;
+    this.persistBuckets();
+    logger.debug(`🗑️ Website config removida: ${bucketName}`);
+    return { success: true };
+  }
+
   // ─── Persistência ─────────────────────────────────────────────────────────
 
   persistBucket(bucketName) {
@@ -395,6 +461,9 @@ class S3Simulator {
       }
       bucketsObj[name] = {
         creationDate: bucket.creationDate.toISOString(),
+        region: bucket.region || "us-east-1",
+        website: bucket.website || false,
+        websiteConfiguration: bucket.websiteConfiguration || null,
         objects: objectsObj,
         objectCount: bucket.objectCount,
         totalSize: bucket.totalSize,

package/src/services/sqs/index.js

@@ -40,17 +40,22 @@ class SQSService {
     const logger = require('../../utils/logger');
     
     for (const queueConfig of this.config.sqs.queues) {
-      if (queueConfig.lambdaPath && this.lambdaService) {
-        const handler = this.lambdaService.getHandler(queueConfig.lambdaPath);
-        if (handler) {
+      if (typeof queueConfig === 'object' && queueConfig.lambdaName && this.lambdaService) {
+        const lambdaSimulator = this.lambdaService.simulator;
+        const lambda = lambdaSimulator?.getLambda(queueConfig.lambdaName);
+
+        if (lambda) {
+          const lambdaName = queueConfig.lambdaName;
+          const handler = async (event) => lambdaSimulator.invoke(lambdaName, event);
+
           this.simulator.attachLambdaToQueue(
             queueConfig.name,
             handler,
             { batchSize: queueConfig.batchSize || 10 }
           );
-          logger.debug(`🔗 Fila ${queueConfig.name} -> Lambda ${queueConfig.lambdaPath}`);
+          logger.debug(`🔗 Fila ${queueConfig.name} -> Lambda ${lambdaName}`);
         } else {
-          logger.warn(`⚠️ Lambda não encontrada para fila ${queueConfig.name}: ${queueConfig.lambdaPath}`);
+          logger.warn(`⚠️ Lambda não encontrada para fila ${queueConfig.name}: ${queueConfig.lambdaName}`);
         }
       }
     }

package/src/services/sqs/server.js

@@ -3,6 +3,7 @@
  */
 
 const express = require('express');
+const cors = require('cors');
 const crypto = require('crypto');
 const SQSSimulator = require('./simulator');
 const logger = require('../../utils/logger');
@@ -19,6 +20,7 @@ class SQSServer {
   }
 
   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)) {

package/src/services/sts/server.js

@@ -1,4 +1,5 @@
 const express = require('express');
+const cors = require('cors');
 const crypto = require('crypto');
 const STSSimulator = require('./simulator');
 const logger = require('../../utils/logger');
@@ -14,6 +15,7 @@ class STSServer {
   }
 
   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)) {