@gugananuvem/aws-local-simulator 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gugananuvem/aws-local-simulator",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Simulador local completo para serviços AWS",
   "main": "src/index.js",
   "bin": {
@@ -120,6 +120,6 @@
       "optional": true
     }
   },
-  "buildDate": "2026-04-20T18:31:32.841Z",
+  "buildDate": "2026-04-21T01:06:51.838Z",
   "published": true
 }

package/src/services/dynamodb/server.js

@@ -20,7 +20,10 @@ class DynamoDBServer {
   setupMiddlewares() {
     this.app.use(cors());
     this.app.use(express.json({
-      type: 'application/x-amz-json-1.0'
+      type: (req) => {
+        const ct = req.headers['content-type'] || '';
+        return ct.includes('application/x-amz-json-1.0') || ct.includes('application/json');
+      }
     }));
     
     // Logging de requisições
@@ -53,6 +56,8 @@ class DynamoDBServer {
         return res.status(400).json({ message: 'Missing X-Amz-Target header' });
       }
 
+      logger.debug(`DynamoDB target=${target} content-type=${req.headers['content-type']} body=${JSON.stringify(req.body)}`);
+
       try {
         const result = await this.simulator.handleRequest(target, req.body);
         res.json(result);

package/src/services/dynamodb/simulator.js

@@ -29,26 +29,24 @@ class DynamoDBSimulator {
   }
 
   loadTables() {
-    // Carrega tabelas da configuração
-    if (this.config.dynamodb?.tables) {
-      for (const tableDef of this.config.dynamodb.tables) {
-        this.createTable(tableDef);
-      }
-    }
-
-    // Carrega tabelas existentes do disco
+    // Carrega tabelas existentes do disco PRIMEIRO para evitar sobrescrever definições persistidas
     const savedTables = this.store.read("__tables__");
     if (savedTables) {
       for (const [name, definition] of Object.entries(savedTables)) {
-        if (!this.tables.has(name)) {
-          this.tables.set(name, definition);
-        }
+        this.tables.set(name, definition);
+      }
+    }
+
+    // Cria tabelas da configuração apenas se ainda não existirem no disco
+    if (this.config.dynamodb?.tables) {
+      for (const tableDef of this.config.dynamodb.tables) {
+        this.createTable(tableDef);
       }
     }
   }
 
   createTable(params) {
-    const { TableName, KeySchema, AttributeDefinitions, ProvisionedThroughput } = params;
+    const { TableName, KeySchema, AttributeDefinitions, ProvisionedThroughput, GlobalSecondaryIndexes } = params;
 
     if (this.tables.has(TableName)) {
       logger.warn(`Tabela ${TableName} já existe`);
@@ -63,11 +61,21 @@ class DynamoDBSimulator {
       attributeTypes[attr.AttributeName] = attr.AttributeType;
     });
 
+    const globalSecondaryIndexes = {};
+    if (GlobalSecondaryIndexes) {
+      for (const gsi of GlobalSecondaryIndexes) {
+        const gsiHashKey = gsi.KeySchema.find((k) => k.KeyType === "HASH").AttributeName;
+        const gsiRangeKey = gsi.KeySchema.find((k) => k.KeyType === "RANGE")?.AttributeName;
+        globalSecondaryIndexes[gsi.IndexName] = { hashKey: gsiHashKey, rangeKey: gsiRangeKey };
+      }
+    }
+
     const table = {
       name: TableName,
       hashKey,
       rangeKey,
       attributeTypes,
+      globalSecondaryIndexes,
       createdAt: new Date().toISOString(),
       itemCount: 0,
       sizeBytes: 0,
@@ -270,13 +278,27 @@ class DynamoDBSimulator {
       throw new Error(`Table ${TableName} does not exist`);
     }
 
-    // Busca o item atual
+    // Busca o item atual (upsert: cria se não existir, como o DynamoDB real)
     const items = this.store.read(TableName);
     const itemKey = this.getItemKeyFromKeys(Key, table);
     const index = items.findIndex((item) => this.getItemKey(item, table) === itemKey);
 
+    // Se não existe, cria um novo item com as chaves fornecidas
     if (index === -1) {
-      throw new Error(`Item not found in ${TableName}`);
+      const newItem = this.normalizeItem(Key, table);
+      newItem._createdAt = new Date().toISOString();
+      newItem._updatedAt = new Date().toISOString();
+      if (UpdateExpression) {
+        this.processUpdateExpression(newItem, UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues, table);
+      }
+      items.push(newItem);
+      this.store.write(TableName, items);
+      logger.verboso(`UpdateItem (upsert): ${TableName}/${itemKey}`);
+      const response = {};
+      if (ReturnValues === "ALL_NEW" || ReturnValues === "UPDATED_NEW") {
+        response.Attributes = this.marshallItem(newItem, table);
+      }
+      return response;
     }
 
     const currentItem = items[index];
@@ -346,6 +368,11 @@ class DynamoDBSimulator {
     const { RequestItems } = params;
     const responses = {};
 
+    if (!RequestItems) {
+      logger.debug(`[DEBUG batchWriteItem] params recebido: ${JSON.stringify(params)}`);
+      throw new Error(`RequestItems is required for BatchWriteItem. Params received: ${JSON.stringify(params)}`);
+    }
+
     for (const [tableName, operations] of Object.entries(RequestItems)) {
       const table = this.tables.get(tableName);
       if (!table) continue;
@@ -424,8 +451,24 @@ class DynamoDBSimulator {
 
     let items = this.store.read(TableName);
 
+    // Resolve hash key e range key: usa GSI se IndexName estiver presente, caso contrário usa a tabela principal
+    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}"`);
+      }
+      hashKey = gsi.hashKey;
+      rangeKey = gsi.rangeKey;
+    } else {
+      hashKey = table.hashKey;
+      rangeKey = table.rangeKey;
+    }
+
     // Filtra pela chave de partição
-    const hashKey = table.hashKey;
     const hashValueMatch = KeyConditionExpression.match(new RegExp(`${hashKey}\\s*=\\s*([^\\s]+)`));
 
     if (hashValueMatch) {
@@ -436,8 +479,7 @@ class DynamoDBSimulator {
     }
 
     // Filtra pela chave de ordenação se existir
-    if (table.rangeKey) {
-      const rangeKey = table.rangeKey;
+    if (rangeKey) {
       const rangeConditionMatch = KeyConditionExpression.match(new RegExp(`${rangeKey}\\s*(=|>|<|>=|<=)\\s*([^\\s]+)`));
 
       if (rangeConditionMatch) {
@@ -562,21 +604,46 @@ class DynamoDBSimulator {
   }
 
   processUpdateExpression(item, expression, nameMap, valueMap, table) {
-    // Implementação simplificada - expandir conforme necessário
-    const setMatch = expression.match(/SET\s+([^]+?)(?=\s+(?:REMOVE|ADD|DELETE)|\s*$)/i);
-
+    // SET clause
+    const setMatch = expression.match(/SET\s+([^]+?)(?=\s+(?:REMOVE|ADD|DELETE)\s|\s*$)/i);
     if (setMatch) {
       const assignments = setMatch[1].split(",").map((a) => a.trim());
-
       for (const assignment of assignments) {
         const [path, valueExpr] = assignment.split("=").map((s) => s.trim());
-        const attributeName = path.replace(/#/g, "");
+        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;
       }
     }
+
+    // ADD clause — incrementa números ou adiciona a sets (upsert-friendly)
+    const addMatch = expression.match(/ADD\s+([^]+?)(?=\s+(?:SET|REMOVE|DELETE)\s|\s*$)/i);
+    if (addMatch) {
+      const assignments = addMatch[1].split(",").map((a) => a.trim());
+      for (const assignment of assignments) {
+        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;
+        const current = item[attributeName];
+        if (current === undefined || current === null) {
+          item[attributeName] = typeof delta === 'number' ? delta : parseFloat(delta) || 0;
+        } else {
+          item[attributeName] = (parseFloat(current) || 0) + (parseFloat(delta) || 0);
+        }
+      }
+    }
+
+    // REMOVE clause
+    const removeMatch = expression.match(/REMOVE\s+([^]+?)(?=\s+(?:SET|ADD|DELETE)\s|\s*$)/i);
+    if (removeMatch) {
+      const attributes = removeMatch[1].split(",").map((a) => a.trim());
+      for (const attr of attributes) {
+        const attributeName = nameMap[attr] || attr.replace(/#/g, "");
+        delete item[attributeName];
+      }
+    }
   }
 
   applyFilter(items, expression, values, table) {

package/src/utils/local-store.js

@@ -31,7 +31,7 @@ class LocalStore {
     if (!fs.existsSync(filePath)) return [];
     
     try {
-      const content = fs.readFileSync(filePath, 'utf8');
+      const content = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
       return JSON.parse(content);
     } catch (error) {
       console.error(`Erro ao ler ${entity}:`, error);