@gugananuvem/aws-local-simulator 1.0.22 → 1.0.26

package/src/services/lambda/simulator.js

@@ -1,7 +1,6 @@
-/**
- * Lambda Simulator - Simula execução de funções Lambda
- */
-
+const LocalStore = require("../../utils/local-store");
+const path = require("path");
+const fs = require("fs");
 const HandlerLoader = require("./handler-loader");
 const logger = require("../../utils/logger");
 const { CloudTrailAudit } = require("../../utils/cloudtrail-audit");
@@ -9,6 +8,8 @@ const { CloudTrailAudit } = require("../../utils/cloudtrail-audit");
 class LambdaSimulator {
   constructor(config) {
     this.config = config;
+    this.dataDir = path.join(process.env.AWS_LOCAL_SIMULATOR_DATA_DIR, "lambda");
+    this.store = new LocalStore(this.dataDir);
     this.lambdas = new Map(); // functionName -> { handler, env, config }
     this.environment = { ...process.env };
     this.audit = new CloudTrailAudit("lambda.amazonaws.com");
@@ -23,15 +24,27 @@ class LambdaSimulator {
     this.globalTimeout = globalDefaults.timeout || null;
     this.globalMemorySize = globalDefaults.memorySize || null;
 
+    // Carrega do config.lambdas (fixo)
     if (this.config.lambdas && this.config.lambdas.length > 0) {
       for (const lambdaConfig of this.config.lambdas) {
         await this.registerLambda(lambdaConfig);
       }
     }
 
+    // Carrega lambdas dinâmicas do disco
+    const savedLambdas = this.store.read("__functions__");
+    if (savedLambdas && Array.isArray(savedLambdas)) {
+      for (const lambdaConfig of savedLambdas) {
+        if (!this.lambdas.has(lambdaConfig.name)) {
+          await this.registerLambda(lambdaConfig);
+        }
+      }
+    }
+
     logger.debug(`✅ ${this.lambdas.size} Lambdas registradas`);
   }
 
+
   async registerLambda(lambdaConfig) {
     try {
       const { name, handler: handlerPath, type = "auto" } = lambdaConfig;
@@ -51,6 +64,14 @@ class LambdaSimulator {
       const memorySize = lambdaConfig.memorySize ?? this.globalMemorySize ?? 128;
 
       const handler = await HandlerLoader.load(handlerPath, type);
+      let codeSize = 0;
+      try {
+        const info = await HandlerLoader.getInfo(handlerPath);
+        codeSize = info.size;
+      } catch (err) {
+        // Ignore size errors
+      }
+
       if (handler != undefined) {
         this.lambdas.set(name, {
           name,
@@ -60,6 +81,7 @@ class LambdaSimulator {
           env,
           timeout,
           memorySize,
+          codeSize,
           type,
           registeredAt: new Date().toISOString(),
         });
@@ -147,16 +169,32 @@ class LambdaSimulator {
   }
 
   listLambdas() {
-    return Array.from(this.lambdas.values()).map((l) => ({
-      name: l.name,
-      handlerName: l.handlerName,
-      handlerPath: l.handlerPath,
-      type: l.type,
-      env: l.env,
-      registeredAt: l.registeredAt,
-    }));
+    return Array.from(this.lambdas.values()).map((l) => {
+      let code = "";
+      try {
+        if (fs.existsSync(l.handlerPath)) {
+          code = fs.readFileSync(l.handlerPath, "utf8");
+        }
+      } catch (err) {
+        logger.error(`Erro ao ler código da lambda ${l.name}:`, err);
+      }
+
+      return {
+        name: l.name,
+        handlerName: l.handlerName,
+        handlerPath: l.handlerPath,
+        type: l.type,
+        env: l.env,
+        timeout: l.timeout,
+        memorySize: l.memorySize,
+        codeSize: l.codeSize,
+        registeredAt: l.registeredAt,
+        code: code
+      };
+    });
   }
 
+
   getLambda(name) {
     return this.lambdas.get(name);
   }
@@ -182,6 +220,91 @@ class LambdaSimulator {
     logger.info(`✅ ${this.lambdas.size} Lambdas recarregadas`);
   }
 
+  async createFunction(lambdaConfig) {
+    const { name, code, runtime, handler, timeout, memorySize, environment } = lambdaConfig;
+
+    if (!name) throw new Error("Function name is required");
+
+    // Define o caminho do arquivo (dentro do dataDir/functions)
+    const functionsDir = path.join(this.dataDir, "functions");
+    if (!fs.existsSync(functionsDir)) fs.mkdirSync(functionsDir, { recursive: true });
+
+    const fileName = `${name}.js`;
+    const filePath = path.join(functionsDir, fileName);
+
+    // Salva o código no disco
+    fs.writeFileSync(filePath, code || "// Hello Lambda");
+
+    // Registra a lambda
+    const config = {
+      name,
+      handler: filePath,
+      runtime: runtime || "nodejs18.x",
+      timeout: timeout || 30,
+      memorySize: memorySize || 128,
+      env: environment || {},
+      type: "commonjs"
+    };
+
+    await this.registerLambda(config);
+    this.persistLambdas();
+
+    return this.lambdas.get(name);
+  }
+
+  async updateFunction(name, lambdaConfig) {
+    const lambda = this.lambdas.get(name);
+    if (!lambda) throw new Error(`Function not found: ${name}`);
+
+    const { code, runtime, handler, timeout, memorySize, environment } = lambdaConfig;
+
+    // Se houver código novo, sobrescreve o arquivo
+    if (code !== undefined) {
+      fs.writeFileSync(lambda.handlerPath, code);
+    }
+
+    // Atualiza a configuração
+    const updatedConfig = {
+      name,
+      handler: lambda.handlerPath,
+      runtime: runtime || lambda.runtime,
+      timeout: timeout || lambda.timeout,
+      memorySize: memorySize || lambda.memorySize,
+      env: environment || lambda.env,
+      type: lambda.type
+    };
+
+    await this.registerLambda(updatedConfig);
+    this.persistLambdas();
+
+    return this.lambdas.get(name);
+  }
+
+  async deleteFunction(name) {
+
+    if (this.lambdas.has(name)) {
+      this.lambdas.delete(name);
+      this.persistLambdas();
+      return true;
+    }
+    return false;
+  }
+
+  persistLambdas() {
+    const functionsToSave = Array.from(this.lambdas.values())
+      .filter(l => l.handlerPath.includes(this.dataDir)) // Apenas as dinâmicas
+      .map(l => ({
+        name: l.name,
+        handler: l.handlerPath,
+        type: l.type,
+        env: l.env,
+        timeout: l.timeout,
+        memorySize: l.memorySize,
+      }));
+
+    this.store.write("__functions__", functionsToSave);
+  }
+
   getStats() {
     return {
       totalLambdas: this.lambdas.size,
@@ -189,6 +312,7 @@ class LambdaSimulator {
     };
   }
 
+
   async reset() {
     await this.reloadLambdas();
     this.environment = { ...process.env };

package/src/services/parameter-store/simulator.js

@@ -50,7 +50,7 @@ class ParameterStoreSimulator {
     const storedValue = Type === 'SecureString' ? this._encrypt(Value) : Value;
     const param = {
       Name, Value: storedValue, Type, Description: Description || '', Version: version,
-      LastModifiedDate: new Date().toISOString(),
+      LastModifiedDate: Math.floor(Date.now() / 1000),
       LastModifiedUser: 'local',
       ARN: `arn:aws:ssm:local:000000000000:parameter${Name}`,
       DataType, Tags: Tags || [], KeyId: Type === 'SecureString' ? (KeyId || 'aws/ssm') : undefined

package/src/services/s3/server.js

@@ -23,6 +23,26 @@ class S3Server {
     this.app.use(express.raw({ type: () => true, limit: '100mb' }));
     this.app.use(express.text({ limit: '100mb' }));
     
+    // Suporte a Virtual Host Style addressing (bucket.localhost:4566)
+    this.app.use((req, res, next) => {
+      const host = req.headers.host || '';
+      // Se o host contém múltiplos pontos e não é apenas um IP ou localhost puro
+      if (host.includes('.') && !host.startsWith('localhost') && !host.startsWith('127.0.0.1')) {
+        const parts = host.split('.');
+        // O primeiro fragmento é o nome do bucket se houver mais de 2 partes (bucket.localhost:port)
+        // ou se a segunda parte for localhost
+        if (parts.length >= 2) {
+          const bucket = parts[0];
+          // Evita processar se for admin ou se já estiver no path style (heurística simples)
+          if (bucket !== 'localhost' && !req.path.startsWith('/__admin/')) {
+            req.url = `/${bucket}${req.url}`;
+            logger.verboso(`S3: Virtual Host Style detected. Rewriting to ${req.url}`);
+          }
+        }
+      }
+      next();
+    });
+
     // Logging de requisições
     if (logger.currentLogLevel === 'verboso') {
       this.app.use((req, res, next) => {
@@ -36,6 +56,7 @@ class S3Server {
     }
   }
 
+
   async initialize() {
     if (!this.simulator) {
       this.simulator = new S3Simulator(this.config);

package/src/services/s3/simulator.js

@@ -489,10 +489,13 @@ class S3Simulator {
   // ─── Utilitários ──────────────────────────────────────────────────────────
 
   isValidBucketName(bucketName) {
-    const regex = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
+    // S3 oficial é rigoroso, mas para simulador local vamos ser mais tolerantes
+    // permitindo underscores e letras maiúsculas que são comuns em testes locais
+    const regex = /^[a-zA-Z0-9][a-zA-Z0-9._-]{1,61}[a-zA-Z0-9]$/;
     return regex.test(bucketName) && !bucketName.includes("..") && !bucketName.includes(".-") && !bucketName.includes("-.");
   }
 
+
   extractMetadata(headers) {
     const metadata = {};
     for (const [key, value] of Object.entries(headers)) {

package/src/services/secret-manager/server.js

@@ -37,7 +37,8 @@ class SecretManagerServer {
       if (!operation) return res.status(400).json({ __type: 'UnknownOperationException', message: `Unknown: ${target}` });
       try {
         const result = await this.simulator[operation](req.body || {});
-        res.json(result || {});
+        res.setHeader('Content-Type', 'application/x-amz-json-1.1');
+        res.send(JSON.stringify(result || {}));
       } catch (err) {
         this.logger.error(`SecretsManager ${target}: ${err.message}`, 'secret-manager');
         res.status(err.code === 'ResourceNotFoundException' ? 404 : 400).json({ __type: err.code || 'InternalServiceError', Message: err.message });

package/src/services/secret-manager/simulator.js

@@ -17,7 +17,18 @@ class SecretManagerSimulator {
   async initialize() {
     try {
       const secrets = await this.store.read('secret-manager/secrets');
-      if (Array.isArray(secrets)) for (const s of secrets) this.secrets.set(s.Name, s);
+      if (Array.isArray(secrets)) {
+        for (const s of secrets) {
+          if (typeof s.CreatedDate === 'string') s.CreatedDate = Math.floor(new Date(s.CreatedDate).getTime() / 1000);
+          if (typeof s.LastChangedDate === 'string') s.LastChangedDate = Math.floor(new Date(s.LastChangedDate).getTime() / 1000);
+          if (s._versions) {
+            for (const v of Object.values(s._versions)) {
+              if (typeof v.CreatedDate === 'string') v.CreatedDate = Math.floor(new Date(v.CreatedDate).getTime() / 1000);
+            }
+          }
+          this.secrets.set(s.Name, s);
+        }
+      }
       this.logger.info('SecretsManager: dados carregados', 'secret-manager');
     } catch { this.logger.debug('SecretsManager: sem dados anteriores', 'secret-manager'); }
   }
@@ -38,12 +49,12 @@ class SecretManagerSimulator {
       ARN: `arn:aws:secretsmanager:local:000000000000:secret:${Name}-${secretId.slice(0, 6)}`,
       Name, Description: Description || '', Tags,
       KmsKeyId: KmsKeyId || 'aws/secretsmanager',
-      CreatedDate: new Date().toISOString(),
-      LastChangedDate: new Date().toISOString(),
+      CreatedDate: Math.floor(Date.now() / 1000),
+      LastChangedDate: Math.floor(Date.now() / 1000),
       LastAccessedDate: null,
       RotationEnabled: false,
       VersionsToStages: { [secretId]: ['AWSCURRENT'] },
-      _versions: { [secretId]: { SecretString, SecretBinary, CreatedDate: new Date().toISOString() } }
+      _versions: { [secretId]: { SecretString, SecretBinary, CreatedDate: Math.floor(Date.now() / 1000) } }
     };
     this.secrets.set(Name, secret);
     await this._persist();
@@ -55,7 +66,7 @@ class SecretManagerSimulator {
   async getSecretValue(params) {
     const { SecretId, VersionId, VersionStage = 'AWSCURRENT' } = params;
     const secret = this._requireSecret(SecretId);
-    secret.LastAccessedDate = new Date().toISOString();
+    secret.LastAccessedDate = Math.floor(Date.now() / 1000);
     let versionId = VersionId;
     if (!versionId) {
       versionId = Object.entries(secret.VersionsToStages).find(([, stages]) => stages.includes(VersionStage))?.[0];
@@ -81,9 +92,9 @@ class SecretManagerSimulator {
         secret.VersionsToStages[vid] = stages.filter(s => s !== 'AWSCURRENT').concat(['AWSPREVIOUS']);
       }
     }
-    secret._versions[versionId] = { SecretString, SecretBinary, CreatedDate: new Date().toISOString() };
+    secret._versions[versionId] = { SecretString, SecretBinary, CreatedDate: Math.floor(Date.now() / 1000) };
     secret.VersionsToStages[versionId] = VersionStages;
-    secret.LastChangedDate = new Date().toISOString();
+    secret.LastChangedDate = Math.floor(Date.now() / 1000);
     await this._persist();
     return { ARN: secret.ARN, Name: secret.Name, VersionId: versionId, VersionStages };
   }
@@ -103,8 +114,8 @@ class SecretManagerSimulator {
   async deleteSecret(params) {
     const { SecretId, RecoveryWindowInDays = 30, ForceDeleteWithoutRecovery } = params;
     const secret = this._requireSecret(SecretId);
-    const deletionDate = ForceDeleteWithoutRecovery ? new Date().toISOString() : new Date(Date.now() + RecoveryWindowInDays * 86400000).toISOString();
-    secret.DeletedDate = new Date().toISOString();
+    const deletionDate = ForceDeleteWithoutRecovery ? Math.floor(Date.now() / 1000) : Math.floor((Date.now() + RecoveryWindowInDays * 86400000) / 1000);
+    secret.DeletedDate = Math.floor(Date.now() / 1000);
     secret.DeletionDate = deletionDate;
     if (ForceDeleteWithoutRecovery) this.secrets.delete(secret.Name);
     await this._persist();
@@ -146,7 +157,7 @@ class SecretManagerSimulator {
     secret.RotationEnabled = true;
     secret.RotationLambdaARN = RotationLambdaARN;
     secret.RotationRules = RotationRules;
-    secret.LastRotatedDate = new Date().toISOString();
+    secret.LastRotatedDate = Math.floor(Date.now() / 1000);
     await this._persist();
     return { ARN: secret.ARN, Name: secret.Name };
   }

package/src/services/sns/server.js

@@ -81,27 +81,39 @@ function createSNSServer(simulator, config, logger) {
   });
 
   app.get('/__admin/topics', (_req, res) => {
-    res.json({ topics: Array.from(simulator.topics.values()) });
+    res.json(Array.from(simulator.topics.values()));
   });
 
+  app.post('/__admin/topics', async (req, res) => {
+    try {
+      const topic = await simulator.createTopic({ Name: req.body.name });
+      res.status(201).json(topic);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+
   app.get('/__admin/subscriptions', (_req, res) => {
-    res.json({ subscriptions: Array.from(simulator.subscriptions.values()) });
+    res.json(Array.from(simulator.subscriptions.values()));
   });
 
   app.get('/__admin/subscriptions/:topicName', (req, res) => {
     const arn  = `arn:aws:sns:us-east-1:123456789012:${req.params.topicName}`;
     const subs = Array.from(simulator.subscriptions.values()).filter(s => s.TopicArn === arn);
-    res.json({ subscriptions: subs });
+    res.json(subs);
   });
 
+
   app.get('/__admin/publish-log', (_req, res) => {
-    res.json({ messages: simulator.publishLog });
+    res.json(simulator.publishLog);
   });
 
   app.get('/__admin/platform-apps', (_req, res) => {
-    res.json({ platformApplications: Array.from(simulator.platformApps.values()) });
+    res.json(Array.from(simulator.platformApps.values()));
   });
 
+
   app.delete('/__admin/topics/:topicName', async (req, res) => {
     try {
       const arn = `arn:aws:sns:us-east-1:123456789012:${req.params.topicName}`;
@@ -112,6 +124,21 @@ function createSNSServer(simulator, config, logger) {
     }
   });
 
+  app.post('/__admin/topics/:topicName/publish', async (req, res) => {
+    try {
+      const arn = `arn:aws:sns:us-east-1:123456789012:${req.params.topicName}`;
+      const result = await simulator.publish({
+        TopicArn: arn,
+        Subject: req.body.subject,
+        Message: req.body.message
+      });
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+
   app.post('/__admin/reset', async (_req, res) => {
     await simulator.reset();
     res.json({ message: 'SNS data reset complete' });

package/src/services/sqs/server.js

@@ -187,7 +187,10 @@ class SQSServer {
         return this.generateReceiveMessageResponse(result.messages);
       case 'DeleteMessage':
         return this.generateDeleteMessageResponse();
+      case 'SetQueueAttributes':
+        return this.generateSetQueueAttributesResponse();
       case 'GetQueueUrl':
+
         return this.generateGetQueueUrlResponse(result.queueUrl);
       case 'ListQueues':
         return this.generateListQueuesResponse(result.queues);
@@ -196,6 +199,14 @@ class SQSServer {
     }
   }
 
+  generateSetQueueAttributesResponse() {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<SetQueueAttributesResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">
+  <ResponseMetadata><RequestId>${crypto.randomUUID()}</RequestId></ResponseMetadata>
+</SetQueueAttributesResponse>`;
+  }
+
+
   generateCreateQueueResponse(queueUrl) {
     return `<?xml version="1.0" encoding="UTF-8"?>
 <CreateQueueResponse xmlns="http://queue.amazonaws.com/doc/2012-11-05/">

package/src/services/sqs/simulator.js

@@ -49,7 +49,7 @@ class SQSSimulator {
     }
   }
 
-  createQueue(queueName) {
+  createQueue(queueName, attributes = {}) {
     if (this.queues.has(queueName)) {
       return { error: { code: 'QueueAlreadyExists', message: 'Queue already exists' }, status: 409 };
     }
@@ -60,12 +60,18 @@ class SQSSimulator {
       arn: `arn:aws:sqs:local:000000000000:${queueName}`,
       messages: [],
       handler: null,
-      batchSize: 10,
-      visibilityTimeout: 30,
+      batchSize: parseInt(attributes.BatchSize || 10),
+      visibilityTimeout: parseInt(attributes.VisibilityTimeout || 30),
+      delaySeconds: parseInt(attributes.DelaySeconds || 0),
+      messageRetentionPeriod: parseInt(attributes.MessageRetentionPeriod || 345600),
       createdAt: new Date().toISOString(),
       messageCount: 0
     };
 
+    if (attributes.LambdaName) {
+      this.attachLambdaToQueue(queueName, attributes.LambdaName, { batchSize: queue.batchSize });
+    }
+
     this.queues.set(queueName, queue);
     this.persistQueues();
     // Only initialize message store if it doesn't already exist
@@ -73,7 +79,7 @@ class SQSSimulator {
       this.store.write(queueName, []);
     }
 
-    logger.debug(`✅ Fila SQS criada: ${queueName}`);
+    logger.debug(`✅ Fila SQS criada: ${queueName} com atributos: ${JSON.stringify(attributes)}`);
 
     return { queue };
   }
@@ -82,6 +88,8 @@ class SQSSimulator {
     switch(action) {
       case 'CreateQueue':
         return this.createQueueAction(req);
+      case 'SetQueueAttributes':
+        return this.setQueueAttributesAction(req);
       case 'SendMessage':
         return this.sendMessageAction(req);
       case 'SendMessageBatch':
@@ -108,9 +116,26 @@ class SQSSimulator {
     return undefined;
   }
 
+  // Parses Attribute.N.Name and Attribute.N.Value from request body/query
+  extractAttributes(req) {
+    const attributes = {};
+    const source = req.body.Action ? req.body : req.query;
+    
+    Object.keys(source).forEach(key => {
+      if (key.startsWith('Attribute.') && key.endsWith('.Name')) {
+        const index = key.split('.')[1];
+        const name = source[key];
+        const value = source[`Attribute.${index}.Value`];
+        attributes[name] = value;
+      }
+    });
+    return attributes;
+  }
+
   createQueueAction(req) {
     const queueName = req.query.QueueName || req.body.QueueName;
-    const result = this.createQueue(queueName);
+    const attributes = this.extractAttributes(req);
+    const result = this.createQueue(queueName, attributes);
 
     if (result.error) {
       return result;
@@ -119,6 +144,39 @@ class SQSSimulator {
     return { queueUrl: result.queue.url };
   }
 
+  setQueueAttributesAction(req) {
+    const queueName = this.resolveQueueName(req);
+    const queue = this.queues.get(queueName);
+
+    if (!queue) {
+      return { error: { code: 'QueueDoesNotExist', message: 'Queue does not exist' }, status: 400 };
+    }
+
+    const attributes = this.extractAttributes(req);
+    
+    if (attributes.DelaySeconds !== undefined) queue.delaySeconds = parseInt(attributes.DelaySeconds);
+    if (attributes.VisibilityTimeout !== undefined) queue.visibilityTimeout = parseInt(attributes.VisibilityTimeout);
+    if (attributes.MessageRetentionPeriod !== undefined) queue.messageRetentionPeriod = parseInt(attributes.MessageRetentionPeriod);
+    
+    if (attributes.LambdaName !== undefined) {
+      queue.lambdaName = attributes.LambdaName;
+      if (attributes.LambdaName) {
+        // Here we'd normally re-attach if we had a direct reference to the lambda service function
+        // For now, we store the name and the server/index.js will handle re-attachment or we use the name to look it up
+        this.attachLambdaToQueue(queueName, attributes.LambdaName, { batchSize: queue.batchSize });
+      } else {
+        queue.handler = null;
+      }
+    }
+    
+    if (attributes.BatchSize !== undefined) {
+      queue.batchSize = parseInt(attributes.BatchSize);
+    }
+
+    this.persistQueues();
+    return { success: true };
+  }
+
   sendMessageAction(req) {
     const queueName = this.resolveQueueName(req);
     const queue = this.queues.get(queueName);
@@ -334,9 +392,13 @@ class SQSSimulator {
         arn: queue.arn,
         batchSize: queue.batchSize,
         visibilityTimeout: queue.visibilityTimeout,
+        delaySeconds: queue.delaySeconds,
+        messageRetentionPeriod: queue.messageRetentionPeriod,
+        lambdaName: queue.lambdaName,
         createdAt: queue.createdAt,
         messageCount: queue.messageCount
       };
+
     }
     this.store.write('__queues__', queuesObj);
   }
@@ -372,10 +434,16 @@ class SQSSimulator {
       name: q.name,
       url: q.url,
       messagesCount: q.messageCount,
-      createdAt: q.createdAt
+      createdAt: q.createdAt,
+      delaySeconds: q.delaySeconds,
+      visibilityTimeout: q.visibilityTimeout,
+      messageRetentionPeriod: q.messageRetentionPeriod,
+      lambdaName: q.lambdaName,
+      batchSize: q.batchSize
     }));
   }
 
+
   getQueue(queueName) {
     const queue = this.queues.get(queueName);
     if (!queue) return null;