@gugananuvem/aws-local-simulator 1.0.29 → 1.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.29",
+  "version": "1.0.30",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -66,6 +66,6 @@
   "publishConfig": {
     "directory": "dist"
   },
-  "buildDate": "2026-04-30T19:05:54.245Z",
+  "buildDate": "2026-05-01T13:34:46.765Z",
   "published": true
 }

package/src/services/cognito/server.js

@@ -164,6 +164,8 @@ class CognitoServer {
         return this.simulator.adminListGroupsForUser(params);
       case 'AdminUserGlobalSignOut':
         return this.simulator.adminUserGlobalSignOut(params);
+      case 'AdminUpdateUserAttributes':
+        return this.simulator.adminUpdateUserAttributes(params);
       
       // Identity Pool Operations
       case 'CreateIdentityPool':

package/src/services/cognito/simulator.js

@@ -1284,6 +1284,28 @@ class CognitoSimulator {
     return password.sort(() => Math.random() - 0.5).join("");
   }
 
+  adminUpdateUserAttributes(params) {
+    const { UserPoolId, Username, UserAttributes } = params;
+    const userPool = this.userPools.get(UserPoolId);
+
+    if (!userPool) {
+      throw new Error(`User pool ${UserPoolId} not found`);
+    }
+
+    const user = this.findUserByUsername(Username, null, UserPoolId);
+    if (!user) {
+      throw new Error(`User not found: ${Username}`);
+    }
+
+    const updates = this.normalizeUserAttributes(UserAttributes || []);
+    Object.assign(user.Attributes, updates);
+    user.LastModifiedDate = Math.floor(Date.now() / 1000);
+    this.persistUsers();
+
+    logger.debug(`✅ AdminUpdateUserAttributes: ${Username} in ${UserPoolId}`);
+    return {};
+  }
+
   adminSetUserPassword(params) {
     const { UserPoolId, Username, Password, Permanent } = params;
     const user = this.findUserByUsername(Username, null, UserPoolId);

package/src/services/lambda/index.js

@@ -36,6 +36,9 @@ class LambdaService {
   injectDependencies(server) {
     const ct = server.getService('cloudtrail');
     if (ct?.simulator) this.simulator.audit.setTrail(ct.simulator);
+
+    const cw = server.getService('cloudwatch');
+    if (cw?.simulator) this.simulator.cloudwatchSimulator = cw.simulator;
   }
 
   async start() {

package/src/services/lambda/server.js

@@ -18,7 +18,6 @@ class LambdaServer {
   }
 
   setupMiddlewares() {
-    this.app.use(express.json({ limit: '10mb' }));
     this.app.use(express.urlencoded({ extended: true }));
     this.app.use(cors());
     
@@ -51,7 +50,22 @@ class LambdaServer {
     this.app.post('/2015-03-31/functions/:functionName/invocations', async (req, res) => {
       const { functionName } = req.params;
       const invocationType = req.headers['x-amz-invocation-type'] || 'RequestResponse';
-      const event = req.body || {};
+
+      // Read body directly from stream, bypassing all body parsers
+      let event = {};
+      try {
+        const rawBody = await new Promise((resolve, reject) => {
+          const chunks = [];
+          req.on('data', chunk => chunks.push(chunk));
+          req.on('end', () => resolve(Buffer.concat(chunks)));
+          req.on('error', reject);
+        });
+        if (rawBody.length > 0) {
+          event = JSON.parse(rawBody.toString('utf8'));
+        }
+      } catch {
+        event = {};
+      }
 
       logger.debug(`Lambda invoke: ${functionName} (${invocationType})`);
 
@@ -77,11 +91,19 @@ class LambdaServer {
   }
 
   setupAdminRoutes() {
+    // Helper: parse Buffer body as JSON for admin routes
+    const parseJson = (req, res, next) => {
+      if (Buffer.isBuffer(req.body) && req.body.length > 0) {
+        try { req.body = JSON.parse(req.body.toString('utf8')); } catch { req.body = {}; }
+      }
+      next();
+    };
+
     this.app.get('/__admin/functions', (req, res) => {
       res.json(this.simulator.listLambdas());
     });
     
-    this.app.post('/__admin/functions', async (req, res) => {
+    this.app.post('/__admin/functions', parseJson, async (req, res) => {
       try {
         const lambda = await this.simulator.createFunction(req.body);
         res.status(201).json(lambda);
@@ -90,7 +112,7 @@ class LambdaServer {
       }
     });
 
-    this.app.put('/__admin/functions/:name', async (req, res) => {
+    this.app.put('/__admin/functions/:name', parseJson, async (req, res) => {
       try {
         const lambda = await this.simulator.updateFunction(req.params.name, req.body);
         res.json(lambda);
@@ -110,7 +132,7 @@ class LambdaServer {
       res.json({ message: 'Lambdas recarregadas', count: this.simulator.getLambdasCount() });
     });
 
-    this.app.post('/__admin/env', (req, res) => {
+    this.app.post('/__admin/env', parseJson, (req, res) => {
       const { key, value } = req.body;
       if (key && value !== undefined) {
         this.simulator.setEnvironmentVariable(key, value);

package/src/services/lambda/simulator.js

@@ -13,6 +13,7 @@ class LambdaSimulator {
     this.lambdas = new Map(); // functionName -> { handler, env, config }
     this.environment = { ...process.env };
     this.audit = new CloudTrailAudit("lambda.amazonaws.com");
+    this.cloudwatchSimulator = null; // injected via injectDependencies
   }
 
   async initialize() {
@@ -108,13 +109,13 @@ class LambdaSimulator {
     logger.debug(`🎯 Invocando Lambda: ${functionName}`);
 
     if (invocationType === "Event") {
-      this.executeHandler(lambda.handler, event).catch((err) => logger.error(`❌ Async Lambda error (${functionName}):`, err));
+      this.executeHandler(lambda, functionName, event).catch((err) => logger.error(`❌ Async Lambda error (${functionName}):`, err));
       return { StatusCode: 202 };
     }
 
     let result;
     try {
-      result = await this.executeHandler(lambda.handler, event);
+      result = await this.executeHandler(lambda, functionName, event);
     } catch (error) {
       logger.error(`❌ Lambda handler error (${functionName}):`, error);
       throw error;
@@ -128,21 +129,63 @@ class LambdaSimulator {
     return { StatusCode: result.statusCode || 200, Payload: result };
   }
 
-  async executeHandler(handler, event) {
-    const context = this.createContext();
-    const result = await handler(event, context);
+  async executeHandler(lambda, functionName, event) {
+    const requestId = Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10);
+    const capturedLogs = [];
+
+    const context = this.createContext(functionName, requestId);
+
+    // Intercept console output during handler execution
+    const origLog = console.log;
+    const origError = console.error;
+    const origWarn = console.warn;
+    const origInfo = console.info;
+
+    const capture = (...args) => {
+      const line = args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ');
+      capturedLogs.push(line);
+    };
+
+    console.log = (...args) => { capture(...args); origLog(...args); };
+    console.error = (...args) => { capture(`[ERROR] ${args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ')}`); origError(...args); };
+    console.warn = (...args) => { capture(`[WARN] ${args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ')}`); origWarn(...args); };
+    console.info = (...args) => { capture(`[INFO] ${args.map(a => (typeof a === 'object' ? JSON.stringify(a) : String(a))).join(' ')}`); origInfo(...args); };
+
+    let result;
+    let execError;
+    try {
+      result = await lambda.handler(event, context);
+    } catch (err) {
+      execError = err;
+      capturedLogs.push(`[ERROR] ${err.message}`);
+    } finally {
+      console.log = origLog;
+      console.error = origError;
+      console.warn = origWarn;
+      console.info = origInfo;
+    }
+
+    // Send logs to CloudWatch asynchronously (non-blocking)
+    if (this.cloudwatchSimulator) {
+      this.cloudwatchSimulator
+        .putLambdaLogs(functionName, requestId, capturedLogs)
+        .catch((err) => logger.debug(`[CloudWatch] Failed to store Lambda logs: ${err.message}`));
+    }
+
+    if (execError) throw execError;
     return result;
   }
 
-  createContext() {
+  createContext(functionName = "local-lambda", requestId = null) {
+    const reqId = requestId || Math.random().toString(36).substring(2, 18);
     return {
-      awsRequestId: Math.random().toString(36).substring(7),
-      functionName: "local-lambda",
+      awsRequestId: reqId,
+      functionName,
       functionVersion: "$LATEST",
-      invokedFunctionArn: "arn:aws:lambda:local:000000000000:function:local-lambda",
+      invokedFunctionArn: `arn:aws:lambda:local:000000000000:function:${functionName}`,
       memoryLimitInMB: "1024",
-      logGroupName: "/aws/lambda/local-lambda",
-      logStreamName: "local-stream",
+      logGroupName: `/aws/lambda/${functionName}`,
+      logStreamName: `${new Date().toISOString().slice(0, 10).replace(/-/g, '/')}/${reqId.slice(0, 8)}`,
       getRemainingTimeInMillis: () => 30000,
       callbackWaitsForEmptyEventLoop: true,
       identity: null,