@gugananuvem/aws-local-simulator 1.0.29 → 1.0.31

package/README.md

@@ -33,7 +33,7 @@ Simulador local completo para serviços AWS. Desenvolva e teste suas aplicaçõe
 ## 📦 Instalação
 
 ```bash
-npm install --save-dev aws-local-simulator
+npm install --save-dev @gugananuvem/aws-local-simulator
 ```
 
 ## 🚀 Uso Rápido

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "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-05T10:06:53.890Z",
   "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

@@ -1222,6 +1222,23 @@ class CognitoSimulator {
       throw new Error(`User pool ${UserPoolId} not found`);
     }
 
+    // Check if a user with the same Username or email already exists in this pool
+    const normalizedAttrs = this.normalizeUserAttributes(UserAttributes || []);
+    const emailToCheck = normalizedAttrs.email;
+
+    const existingUser = Array.from(this.users.values()).find((u) => {
+      if (u.UserPoolId !== UserPoolId) return false;
+      if (u.Username === Username) return true;
+      if (emailToCheck && u.Attributes?.email === emailToCheck) return true;
+      return false;
+    });
+
+    if (existingUser) {
+      const err = new Error(`User account already exists`);
+      err.code = "UsernameExistsException";
+      throw err;
+    }
+
     const tempPassword = TemporaryPassword || this._generateTemporaryPassword();
 
     const userId = uuidv4();
@@ -1229,7 +1246,7 @@ class CognitoSimulator {
       Username: Username,
       UserPoolId: UserPoolId,
       UserId: userId,
-      Attributes: this.normalizeUserAttributes(UserAttributes || []),
+      Attributes: normalizedAttrs,
       Enabled: true,
       UserStatus: "FORCE_CHANGE_PASSWORD",
       CreatedDate: new Date().toISOString(),
@@ -1242,7 +1259,7 @@ class CognitoSimulator {
 
     // PreSignUp trigger — dispara antes de criar o usuário (admin context)
     const preSignUpEvent = this._buildTriggerEvent("PreSignUp_AdminCreateUser", userPool, user, "ADMIN", {
-      userAttributes: this.normalizeUserAttributes(UserAttributes || []),
+      userAttributes: normalizedAttrs,
       validationData: {},
       clientMetadata: {},
     });
@@ -1284,6 +1301,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/dynamodb/server.js

@@ -85,7 +85,16 @@ class DynamoDBServer {
     });
     
     this.app.get('/__admin/tables/:tableName/items', (req, res) => {
-      const items = this.simulator.scan({ TableName: req.params.tableName });
+      const params = { TableName: req.params.tableName };
+      if (req.query.Limit) params.Limit = Number(req.query.Limit);
+      if (req.query.ExclusiveStartKey) {
+        try {
+          params.ExclusiveStartKey = JSON.parse(req.query.ExclusiveStartKey);
+        } catch (e) {
+          // Ignore invalid JSON for ExclusiveStartKey
+        }
+      }
+      const items = this.simulator.scan(params);
       res.json(items);
     });
     

package/src/services/dynamodb/simulator.js

@@ -550,7 +550,18 @@ class DynamoDBSimulator {
   }
 
   query(params) {
-    const { TableName, KeyConditionExpression, ExpressionAttributeValues, ExpressionAttributeNames = {}, IndexName } = params;
+    const { 
+      TableName, 
+      KeyConditionExpression, 
+      FilterExpression,
+      ExpressionAttributeValues, 
+      ExpressionAttributeNames = {}, 
+      IndexName,
+      Limit,
+      ExclusiveStartKey,
+      ProjectionExpression,
+      ScanIndexForward = true
+    } = params;
     const table = this.tables.get(TableName);
 
     if (!table) {
@@ -559,21 +570,13 @@ class DynamoDBSimulator {
 
     let items = this.store.read(TableName);
 
-    // Resolve hash key e range key
-    let hashKey;
-    let rangeKey;
-
-    if (IndexName != null) {
-      const gsiDefs = table.globalSecondaryIndexes || {};
-      const gsi = gsiDefs[IndexName];
-      if (!gsi) {
-        throw new Error(`GSI "${IndexName}" not found on table "${TableName}"`);
+    // Se for consulta por índice, filtra itens que não possuem as chaves do índice (Sparse Index)
+    if (IndexName && table.globalSecondaryIndexes?.[IndexName]) {
+      const gsi = table.globalSecondaryIndexes[IndexName];
+      items = items.filter(item => item[gsi.hashKey] !== undefined);
+      if (gsi.rangeKey) {
+        items = items.filter(item => item[gsi.rangeKey] !== undefined);
       }
-      hashKey = gsi.hashKey;
-      rangeKey = gsi.rangeKey;
-    } else {
-      hashKey = table.hashKey;
-      rangeKey = table.rangeKey;
     }
 
     // Helper para resolver nomes de atributos (que podem ser placeholders como #n0)
@@ -586,7 +589,6 @@ class DynamoDBSimulator {
     const resolveValue = (placeholder) => {
       const rawValue = ExpressionAttributeValues[placeholder];
       if (rawValue === undefined) return undefined;
-      // Se for formato DynamoDB { S: "..." }, desmembra. Se for nativo (DocumentClient), usa direto.
       if (rawValue !== null && typeof rawValue === 'object' && !Array.isArray(rawValue)) {
         const keys = Object.keys(rawValue);
         if (keys.length === 1 && ["S", "N", "BOOL", "NULL", "M", "L", "SS", "NS", "BS"].includes(keys[0])) {
@@ -597,31 +599,23 @@ class DynamoDBSimulator {
     };
 
     // Filtra pela KeyConditionExpression
-    // DynamoDB Query KeyConditionExpression tem formato restrito: PartitionKey = :val AND (SortKey operator :val)
     if (KeyConditionExpression) {
       const parts = KeyConditionExpression.split(/\s+AND\s+/i);
-      
       for (const part of parts) {
         const match = part.match(/([^\s]+)\s*(=|>|<|>=|<=|BEGINS_WITH|BETWEEN)\s*([^\s]+)(?:\s+AND\s+([^\s]+))?/i);
         if (match) {
           const attrPlaceholder = match[1];
           const operator = match[2].toUpperCase();
           const valPlaceholder = match[3];
-          
           const attributeName = resolveAttributeName(attrPlaceholder);
           const expectedValue = resolveValue(valPlaceholder);
 
-          if (operator === "=") {
-            items = items.filter(item => item[attributeName] === expectedValue);
-          } else if (operator === ">") {
-            items = items.filter(item => item[attributeName] > expectedValue);
-          } else if (operator === "<") {
-            items = items.filter(item => item[attributeName] < expectedValue);
-          } else if (operator === ">=") {
-            items = items.filter(item => item[attributeName] >= expectedValue);
-          } else if (operator === "<=") {
-            items = items.filter(item => item[attributeName] <= expectedValue);
-          } else if (operator === "BEGINS_WITH") {
+          if (operator === "=") items = items.filter(item => item[attributeName] === expectedValue);
+          else if (operator === ">") items = items.filter(item => item[attributeName] > expectedValue);
+          else if (operator === "<") items = items.filter(item => item[attributeName] < expectedValue);
+          else if (operator === ">=") items = items.filter(item => item[attributeName] >= expectedValue);
+          else if (operator === "<=") items = items.filter(item => item[attributeName] <= expectedValue);
+          else if (operator === "BEGINS_WITH") {
             const val = expectedValue;
             items = items.filter(item => String(item[attributeName] || "").startsWith(String(val)));
           }
@@ -629,44 +623,148 @@ class DynamoDBSimulator {
       }
     }
 
-    const marshalledItems = items.map((item) => this.marshallItem(item, table));
+    // Ordenação (DynamoDB sempre ordena pela Sort Key)
+    let sortKey = table.rangeKey;
+    if (IndexName && table.globalSecondaryIndexes?.[IndexName]) {
+      sortKey = table.globalSecondaryIndexes[IndexName].rangeKey;
+    }
+
+    if (sortKey) {
+      items.sort((a, b) => {
+        const valA = a[sortKey];
+        const valB = b[sortKey];
+        
+        if (valA === valB) return 0;
+        if (valA === undefined || valA === null) return 1;
+        if (valB === undefined || valB === null) return -1;
+        
+        let comparison = 0;
+        if (typeof valA === 'number' && typeof valB === 'number') {
+          comparison = valA - valB;
+        } else {
+          comparison = String(valA).localeCompare(String(valB));
+        }
+        
+        return ScanIndexForward ? comparison : -comparison;
+      });
+    }
+
+    const scannedCount = items.length;
+
+    // Aplica FilterExpression se existir
+    if (FilterExpression) {
+      items = this.applyFilter(items, FilterExpression, ExpressionAttributeValues, ExpressionAttributeNames, table);
+    }
+
+    const totalMatchingCount = items.length;
+
+    // Apply Pagination (ExclusiveStartKey)
+    if (ExclusiveStartKey) {
+      const startKeyStr = this.getItemKeyFromKeys(ExclusiveStartKey, table);
+      const startIndex = items.findIndex(item => this.getItemKey(item, table) === startKeyStr);
+      if (startIndex !== -1) {
+        items = items.slice(startIndex + 1);
+      }
+    }
+
+    // Apply Limit
+    let lastEvaluatedKey = null;
+    if (Limit && items.length > Limit) {
+      const lastItem = items[Limit - 1];
+      lastEvaluatedKey = this.marshallItem(lastItem, table);
+      items = items.slice(0, Limit);
+    }
+
+    let marshalledItems = items.map((item) => this.marshallItem(item, table));
+
+    // Apply Projection
+    if (ProjectionExpression) {
+      marshalledItems = this.applyProjection(marshalledItems, ProjectionExpression, ExpressionAttributeNames);
+    }
 
     return {
       Items: marshalledItems,
       Count: marshalledItems.length,
-      ScannedCount: items.length,
+      ScannedCount: scannedCount,
+      LastEvaluatedKey: lastEvaluatedKey || undefined
     };
   }
 
   scan(params) {
-    const { TableName, FilterExpression, ExpressionAttributeValues, ExpressionAttributeNames = {}, Limit } = params;
+    const { 
+      TableName, 
+      FilterExpression, 
+      ExpressionAttributeValues, 
+      ExpressionAttributeNames = {}, 
+      Limit,
+      ExclusiveStartKey,
+      ProjectionExpression
+    } = params;
     const table = this.tables.get(TableName);
 
     if (!table) {
       throw new Error(`Table ${TableName} does not exist`);
     }
 
-    let items = this.store.read(TableName);
+    const allItems = this.store.read(TableName);
+    let items = allItems;
+    const scannedCount = items.length;
 
     // Aplica filtro se existir
     if (FilterExpression) {
       items = this.applyFilter(items, FilterExpression, ExpressionAttributeValues, ExpressionAttributeNames, table);
     }
 
-    // Aplica limite
+    // Apply Pagination (ExclusiveStartKey)
+    if (ExclusiveStartKey) {
+      const startKeyStr = this.getItemKeyFromKeys(ExclusiveStartKey, table);
+      const startIndex = items.findIndex(item => this.getItemKey(item, table) === startKeyStr);
+      if (startIndex !== -1) {
+        items = items.slice(startIndex + 1);
+      }
+    }
+
+    // Apply Limit
+    let lastEvaluatedKey = null;
     if (Limit && items.length > Limit) {
+      const lastItem = items[Limit - 1];
+      lastEvaluatedKey = this.marshallItem(lastItem, table);
       items = items.slice(0, Limit);
     }
 
-    const marshalledItems = items.map((item) => this.marshallItem(item, table));
+    let marshalledItems = items.map((item) => this.marshallItem(item, table));
+
+    // Apply Projection
+    if (ProjectionExpression) {
+      marshalledItems = this.applyProjection(marshalledItems, ProjectionExpression, ExpressionAttributeNames);
+    }
 
     return {
       Items: marshalledItems,
       Count: marshalledItems.length,
-      ScannedCount: items.length,
+      ScannedCount: scannedCount,
+      LastEvaluatedKey: lastEvaluatedKey || undefined
     };
   }
 
+  applyProjection(items, expression, names = {}) {
+    const projectedAttrs = expression.split(',').map(s => s.trim()).filter(Boolean);
+    const resolvedAttrs = projectedAttrs.map(attr => {
+      if (attr.startsWith("#")) return names[attr] || attr;
+      return attr;
+    });
+
+    return items.map(item => {
+      const newItem = {};
+      resolvedAttrs.forEach(attr => {
+        if (item[attr] !== undefined) {
+          newItem[attr] = item[attr];
+        }
+      });
+      return newItem;
+    });
+  }
+
 
   // Métodos auxiliares
   normalizeItem(item, table) {
@@ -748,8 +846,8 @@ class DynamoDBSimulator {
         const [path, valueExpr] = assignment.split("=").map((s) => s.trim());
         const attributeName = nameMap[path] || path.replace(/#/g, "");
         const rawValue = valueMap[valueExpr];
-        const value = rawValue && typeof rawValue === 'object' ? Object.values(rawValue)[0] : rawValue;
-        item[attributeName] = value;
+        // Usa normalizeValue para garantir o mesmo formato que o putItem
+        item[attributeName] = this.normalizeValue(rawValue, table);
       }
     }
 
@@ -761,7 +859,8 @@ class DynamoDBSimulator {
         const parts = assignment.split(/\s+/);
         const attributeName = nameMap[parts[0]] || parts[0].replace(/#/g, "");
         const rawValue = valueMap[parts[1]];
-        const delta = rawValue && typeof rawValue === 'object' ? Object.values(rawValue)[0] : rawValue;
+        // Usa normalizeValue para garantir o mesmo formato que o putItem
+        const delta = this.normalizeValue(rawValue, table);
         const current = item[attributeName];
         if (current === undefined || current === null) {
           item[attributeName] = typeof delta === 'number' ? delta : parseFloat(delta) || 0;

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,