@gugananuvem/aws-local-simulator 1.0.30 → 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.30",
+  "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-05-01T13:34:46.765Z",
+  "buildDate": "2026-05-05T10:06:53.890Z",
   "published": true
 }

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: {},
     });

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;