@gugananuvem/aws-local-simulator 1.0.0 → 1.0.2

package/src/services/dynamodb/simulator.js

@@ -0,0 +1,614 @@
+/**
+ * DynamoDB Simulator Core
+ */
+
+const LocalStore = require("../../utils/local-store");
+const logger = require("../../utils/logger");
+const crypto = require("crypto");
+const path = require("path");
+
+class DynamoDBSimulator {
+  constructor(config) {
+    this.config = config;
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || "./.aws-local-simulator-data";
+
+    if (!dataDir) {
+      throw new Error("AWS_LOCAL_SIMULATOR_DATA_DIR not set");
+    }
+
+    this.dataDir = path.join(dataDir, "dynamodb");
+    this.store = new LocalStore(this.dataDir);
+    this.tables = new Map();
+  }
+  async initialize() {
+    logger.debug("Inicializando DynamoDB Simulator...");
+    this.loadTables();
+    logger.debug(`✅ DynamoDB Simulator inicializado com ${this.tables.size} tabelas`);
+  }
+
+  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
+    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);
+        }
+      }
+    }
+  }
+
+  createTable(params) {
+    const { TableName, KeySchema, AttributeDefinitions, ProvisionedThroughput } = params;
+
+    if (this.tables.has(TableName)) {
+      logger.warn(`Tabela ${TableName} já existe`);
+      return { TableDescription: { TableName, TableStatus: "ACTIVE" } };
+    }
+
+    const hashKey = KeySchema.find((k) => k.KeyType === "HASH").AttributeName;
+    const rangeKey = KeySchema.find((k) => k.KeyType === "RANGE")?.AttributeName;
+
+    const attributeTypes = {};
+    AttributeDefinitions.forEach((attr) => {
+      attributeTypes[attr.AttributeName] = attr.AttributeType;
+    });
+
+    const table = {
+      name: TableName,
+      hashKey,
+      rangeKey,
+      attributeTypes,
+      createdAt: new Date().toISOString(),
+      itemCount: 0,
+      sizeBytes: 0,
+    };
+
+    this.tables.set(TableName, table);
+    this.persistTables();
+
+    // Inicializa arquivo de dados
+    this.store.write(TableName, []);
+
+    logger.debug(`✅ Tabela criada: ${TableName}`);
+
+    return {
+      TableDescription: {
+        TableName,
+        TableStatus: "ACTIVE",
+        CreationDateTime: new Date().toISOString(),
+        KeySchema,
+        AttributeDefinitions,
+        ProvisionedThroughput: ProvisionedThroughput || {
+          ReadCapacityUnits: 5,
+          WriteCapacityUnits: 5,
+        },
+        ItemCount: 0,
+        TableSizeBytes: 0,
+      },
+    };
+  }
+
+  async handleRequest(target, params) {
+    const action = target.split(".")[1];
+
+    logger.verboso(`DynamoDB Action: ${action}`, params);
+
+    switch (action) {
+      case "CreateTable":
+        return this.createTable(params);
+      case "DescribeTable":
+        return this.describeTable(params.TableName);
+      case "ListTables":
+        return this.listTables(params);
+      case "DeleteTable":
+        return this.deleteTable(params);
+      case "PutItem":
+        return this.putItem(params);
+      case "GetItem":
+        return this.getItem(params);
+      case "UpdateItem":
+        return this.updateItem(params);
+      case "DeleteItem":
+        return this.deleteItem(params);
+      case "BatchWriteItem":
+        return this.batchWriteItem(params);
+      case "BatchGetItem":
+        return this.batchGetItem(params);
+      case "Query":
+        return this.query(params);
+      case "Scan":
+        return this.scan(params);
+      default:
+        throw new Error(`Unsupported action: ${action}`);
+    }
+  }
+
+  describeTable(tableName) {
+    const table = this.tables.get(tableName);
+    if (!table) {
+      throw new Error(`Table ${tableName} does not exist`);
+    }
+
+    const items = this.store.read(tableName);
+
+    return {
+      Table: {
+        TableName: table.name,
+        TableStatus: "ACTIVE",
+        CreationDateTime: table.createdAt,
+        KeySchema: [{ AttributeName: table.hashKey, KeyType: "HASH" }, ...(table.rangeKey ? [{ AttributeName: table.rangeKey, KeyType: "RANGE" }] : [])],
+        AttributeDefinitions: Object.entries(table.attributeTypes).map(([name, type]) => ({
+          AttributeName: name,
+          AttributeType: type,
+        })),
+        ItemCount: items.length,
+        TableSizeBytes: JSON.stringify(items).length,
+        ProvisionedThroughput: {
+          ReadCapacityUnits: 5,
+          WriteCapacityUnits: 5,
+        },
+      },
+    };
+  }
+
+  listTables(params = {}) {
+    const tableNames = Array.from(this.tables.keys());
+    const { Limit = 100, ExclusiveStartTableName } = params;
+
+    let startIndex = 0;
+    if (ExclusiveStartTableName) {
+      const index = tableNames.indexOf(ExclusiveStartTableName);
+      if (index !== -1) startIndex = index + 1;
+    }
+
+    const result = tableNames.slice(startIndex, startIndex + Limit);
+
+    return {
+      TableNames: result,
+      LastEvaluatedTableName: result.length === Limit ? result[result.length - 1] : undefined,
+    };
+  }
+
+  deleteTable(params) {
+    const { TableName } = params;
+
+    if (!this.tables.has(TableName)) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    this.tables.delete(TableName);
+    this.store.delete(TableName);
+    this.persistTables();
+
+    return { TableDescription: { TableName, TableStatus: "DELETING" } };
+  }
+
+  putItem(params) {
+    const { TableName, Item, ReturnValues = "NONE" } = params;
+    const table = this.tables.get(TableName);
+
+    if (!table) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    // Normaliza o item
+    const normalizedItem = this.normalizeItem(Item, table);
+    normalizedItem._createdAt = normalizedItem._createdAt || new Date().toISOString();
+    normalizedItem._updatedAt = new Date().toISOString();
+
+    // Carrega dados existentes
+    let items = this.store.read(TableName);
+    const itemKey = this.getItemKey(normalizedItem, table);
+
+    // Encontra e substitui ou adiciona
+    const existingIndex = items.findIndex((item) => this.getItemKey(item, table) === itemKey);
+
+    let oldItem = null;
+    if (existingIndex !== -1) {
+      oldItem = { ...items[existingIndex] };
+      items[existingIndex] = normalizedItem;
+    } else {
+      items.push(normalizedItem);
+      table.itemCount++;
+    }
+
+    // Salva no store
+    this.store.write(TableName, items);
+    this.persistTables();
+
+    logger.verboso(`PutItem: ${TableName}/${itemKey}`);
+
+    const response = {};
+    if (ReturnValues === "ALL_OLD" && oldItem) {
+      response.Attributes = this.marshallItem(oldItem, table);
+    }
+
+    return response;
+  }
+
+  getItem(params) {
+    const { TableName, Key } = params;
+    const table = this.tables.get(TableName);
+
+    if (!table) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    const items = this.store.read(TableName);
+    const itemKey = this.getItemKeyFromKeys(Key, table);
+
+    const item = items.find((item) => this.getItemKey(item, table) === itemKey);
+
+    logger.verboso(`GetItem: ${TableName}/${itemKey} - ${item ? "found" : "not found"}`);
+
+    return item ? { Item: this.marshallItem(item, table) } : {};
+  }
+
+  updateItem(params) {
+    const { TableName, Key, UpdateExpression, ExpressionAttributeNames = {}, ExpressionAttributeValues = {}, ReturnValues = "NONE" } = params;
+    const table = this.tables.get(TableName);
+
+    if (!table) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    // Busca o item atual
+    const items = this.store.read(TableName);
+    const itemKey = this.getItemKeyFromKeys(Key, table);
+    const index = items.findIndex((item) => this.getItemKey(item, table) === itemKey);
+
+    if (index === -1) {
+      throw new Error(`Item not found in ${TableName}`);
+    }
+
+    const currentItem = items[index];
+    const updatedItem = { ...currentItem };
+    updatedItem._updatedAt = new Date().toISOString();
+
+    // Processa a UpdateExpression
+    if (UpdateExpression) {
+      this.processUpdateExpression(updatedItem, UpdateExpression, ExpressionAttributeNames, ExpressionAttributeValues, table);
+    }
+
+    // Salva o item atualizado
+    const oldItem = { ...items[index] };
+    items[index] = updatedItem;
+    this.store.write(TableName, items);
+
+    logger.verboso(`UpdateItem: ${TableName}/${itemKey}`);
+
+    const response = {};
+    switch (ReturnValues) {
+      case "ALL_OLD":
+        response.Attributes = this.marshallItem(oldItem, table);
+        break;
+      case "ALL_NEW":
+        response.Attributes = this.marshallItem(updatedItem, table);
+        break;
+      default:
+        break;
+    }
+
+    return response;
+  }
+
+  deleteItem(params) {
+    const { TableName, Key, ReturnValues = "NONE" } = params;
+    const table = this.tables.get(TableName);
+
+    if (!table) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    const items = this.store.read(TableName);
+    const itemKey = this.getItemKeyFromKeys(Key, table);
+    const index = items.findIndex((item) => this.getItemKey(item, table) === itemKey);
+
+    if (index === -1) {
+      return {};
+    }
+
+    const oldItem = { ...items[index] };
+    items.splice(index, 1);
+    this.store.write(TableName, items);
+    table.itemCount--;
+    this.persistTables();
+
+    logger.verboso(`DeleteItem: ${TableName}/${itemKey}`);
+
+    const response = {};
+    if (ReturnValues === "ALL_OLD") {
+      response.Attributes = this.marshallItem(oldItem, table);
+    }
+
+    return response;
+  }
+
+  batchWriteItem(params) {
+    const { RequestItems } = params;
+    const responses = {};
+
+    for (const [tableName, operations] of Object.entries(RequestItems)) {
+      const table = this.tables.get(tableName);
+      if (!table) continue;
+
+      let items = this.store.read(tableName);
+      const unprocessedItems = [];
+
+      for (const op of operations) {
+        if (op.PutRequest) {
+          const item = this.normalizeItem(op.PutRequest.Item, table);
+          const itemKey = this.getItemKey(item, table);
+          const index = items.findIndex((i) => this.getItemKey(i, table) === itemKey);
+
+          if (index !== -1) {
+            items[index] = item;
+          } else {
+            items.push(item);
+            table.itemCount++;
+          }
+        } else if (op.DeleteRequest) {
+          const key = op.DeleteRequest.Key;
+          const itemKey = this.getItemKeyFromKeys(key, table);
+          const index = items.findIndex((i) => this.getItemKey(i, table) === itemKey);
+
+          if (index !== -1) {
+            items.splice(index, 1);
+            table.itemCount--;
+          } else {
+            unprocessedItems.push(op);
+          }
+        }
+      }
+
+      this.store.write(tableName, items);
+      responses[tableName] = { UnprocessedItems: unprocessedItems };
+    }
+
+    this.persistTables();
+
+    return { UnprocessedItems: responses };
+  }
+
+  batchGetItem(params) {
+    const { RequestItems } = params;
+    const responses = {};
+
+    for (const [tableName, request] of Object.entries(RequestItems)) {
+      const table = this.tables.get(tableName);
+      if (!table) continue;
+
+      const items = this.store.read(tableName);
+      const { Keys } = request;
+      const foundItems = [];
+
+      for (const key of Keys) {
+        const itemKey = this.getItemKeyFromKeys(key, table);
+        const item = items.find((i) => this.getItemKey(i, table) === itemKey);
+        if (item) {
+          foundItems.push(this.marshallItem(item, table));
+        }
+      }
+
+      responses[tableName] = { Items: foundItems };
+    }
+
+    return { Responses: responses };
+  }
+
+  query(params) {
+    const { TableName, KeyConditionExpression, ExpressionAttributeValues, IndexName } = params;
+    const table = this.tables.get(TableName);
+
+    if (!table) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    let items = this.store.read(TableName);
+
+    // Filtra pela chave de partição
+    const hashKey = table.hashKey;
+    const hashValueMatch = KeyConditionExpression.match(new RegExp(`${hashKey}\\s*=\\s*([^\\s]+)`));
+
+    if (hashValueMatch) {
+      const hashValuePlaceholder = hashValueMatch[1];
+      const hashValue = ExpressionAttributeValues[hashValuePlaceholder];
+      items = items.filter((item) => item[hashKey] === hashValue);
+    }
+
+    // Filtra pela chave de ordenação se existir
+    if (table.rangeKey) {
+      const rangeKey = table.rangeKey;
+      const rangeConditionMatch = KeyConditionExpression.match(new RegExp(`${rangeKey}\\s*(=|>|<|>=|<=)\\s*([^\\s]+)`));
+
+      if (rangeConditionMatch) {
+        const operator = rangeConditionMatch[1];
+        const rangeValuePlaceholder = rangeConditionMatch[2];
+        const rangeValue = ExpressionAttributeValues[rangeValuePlaceholder];
+
+        items = items.filter((item) => {
+          const itemValue = item[rangeKey];
+          switch (operator) {
+            case "=":
+              return itemValue === rangeValue;
+            case ">":
+              return itemValue > rangeValue;
+            case "<":
+              return itemValue < rangeValue;
+            case ">=":
+              return itemValue >= rangeValue;
+            case "<=":
+              return itemValue <= rangeValue;
+            default:
+              return true;
+          }
+        });
+      }
+    }
+
+    const marshalledItems = items.map((item) => this.marshallItem(item, table));
+
+    return {
+      Items: marshalledItems,
+      Count: marshalledItems.length,
+      ScannedCount: items.length,
+    };
+  }
+
+  scan(params) {
+    const { TableName, FilterExpression, ExpressionAttributeValues, Limit } = params;
+    const table = this.tables.get(TableName);
+
+    if (!table) {
+      throw new Error(`Table ${TableName} does not exist`);
+    }
+
+    let items = this.store.read(TableName);
+
+    // Aplica filtro se existir
+    if (FilterExpression) {
+      items = this.applyFilter(items, FilterExpression, ExpressionAttributeValues, table);
+    }
+
+    // Aplica limite
+    if (Limit && items.length > Limit) {
+      items = items.slice(0, Limit);
+    }
+
+    const marshalledItems = items.map((item) => this.marshallItem(item, table));
+
+    return {
+      Items: marshalledItems,
+      Count: marshalledItems.length,
+      ScannedCount: items.length,
+    };
+  }
+
+  // Métodos auxiliares
+  normalizeItem(item, table) {
+    const normalized = { ...item };
+
+    // Remove os tipos do DynamoDB (S, N, etc)
+    for (const [key, value] of Object.entries(normalized)) {
+      if (value && typeof value === "object") {
+        if (value.S !== undefined) normalized[key] = value.S;
+        else if (value.N !== undefined) normalized[key] = parseFloat(value.N);
+        else if (value.BOOL !== undefined) normalized[key] = value.BOOL;
+        else if (value.L !== undefined) normalized[key] = value.L.map((v) => this.normalizeItem(v, table));
+        else if (value.M !== undefined) normalized[key] = this.normalizeItem(value.M, table);
+      }
+    }
+
+    return normalized;
+  }
+
+  marshallItem(item, table) {
+    const marshalled = {};
+
+    for (const [key, value] of Object.entries(item)) {
+      if (key.startsWith("_")) continue; // Pula campos internos
+
+      const type = table.attributeTypes[key];
+      if (type === "S") {
+        marshalled[key] = { S: String(value) };
+      } else if (type === "N") {
+        marshalled[key] = { N: String(value) };
+      } else if (type === "BOOL") {
+        marshalled[key] = { BOOL: Boolean(value) };
+      } else if (Array.isArray(value)) {
+        marshalled[key] = { L: value.map((v) => ({ S: String(v) })) };
+      } else if (typeof value === "object") {
+        marshalled[key] = { M: this.marshallItem(value, table) };
+      } else {
+        marshalled[key] = { S: String(value) };
+      }
+    }
+
+    return marshalled;
+  }
+
+  getItemKey(item, table) {
+    const hashValue = item[table.hashKey];
+    const rangeValue = table.rangeKey ? item[table.rangeKey] : null;
+    return rangeValue ? `${hashValue}|${rangeValue}` : String(hashValue);
+  }
+
+  getItemKeyFromKeys(keys, table) {
+    const hashValue = keys[table.hashKey];
+    const rangeValue = table.rangeKey ? keys[table.rangeKey] : null;
+    return rangeValue ? `${hashValue}|${rangeValue}` : String(hashValue);
+  }
+
+  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);
+
+    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 value = valueMap[valueExpr];
+
+        item[attributeName] = value;
+      }
+    }
+  }
+
+  applyFilter(items, expression, values, table) {
+    // Implementação simplificada
+    return items.filter((item) => {
+      const match = expression.match(/([^\s]+)\s*=\s*([^\s]+)/);
+      if (match) {
+        const [, attribute, placeholder] = match;
+        const expectedValue = values[placeholder];
+        const actualValue = item[attribute];
+        return actualValue === expectedValue;
+      }
+      return true;
+    });
+  }
+
+  persistTables() {
+    const tablesObj = {};
+    for (const [name, table] of this.tables.entries()) {
+      tablesObj[name] = table;
+    }
+    this.store.write("__tables__", tablesObj);
+  }
+
+  async reset() {
+    for (const [tableName] of this.tables) {
+      this.store.write(tableName, []);
+    }
+    logger.debug("DynamoDB: Todos os dados resetados");
+  }
+
+  getTablesCount() {
+    return this.tables.size;
+  }
+
+  getTotalItems() {
+    let total = 0;
+    for (const [tableName] of this.tables) {
+      const items = this.store.read(tableName);
+      total += items.length;
+    }
+    return total;
+  }
+
+  listTables() {
+    return { TableNames: Array.from(this.tables.keys()) };
+  }
+}
+
+module.exports = DynamoDBSimulator;

package/src/services/eventbridge/index.js

@@ -0,0 +1,85 @@
+/**
+ * EventBridge Service - Ponto de entrada (Stub para implementação futura)
+ */
+
+const logger = require('../../utils/logger');
+
+class EventBridgeService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'eventbridge';
+    this.port = config.ports.eventbridge;
+    this.isRunning = false;
+    this.buses = new Map();
+    this.events = [];
+  }
+
+  async initialize() {
+    logger.debug(`Inicializando EventBridge Service na porta ${this.port}...`);
+    logger.warn('⚠️ EventBridge Service ainda não está completamente implementado');
+    
+    // TODO: Implementar EventBridge simulator
+    this.buses = new Map();
+    this.events = [];
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    
+    // TODO: Iniciar servidor HTTP para EventBridge
+    this.isRunning = true;
+    logger.info(`🎯 EventBridge Service stub rodando (porta ${this.port}) - Implementação em breve`);
+  }
+
+  async stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+  }
+
+  async reset() {
+    this.buses.clear();
+    this.events = [];
+    logger.debug('EventBridge: Todos os dados resetados');
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      implemented: false,
+      busesCount: this.buses.size,
+      eventsCount: this.events.length
+    };
+  }
+
+  // Métodos stub para compatibilidade
+  async createEventBus(name) {
+    if (!this.buses.has(name)) {
+      this.buses.set(name, {
+        name,
+        arn: `arn:aws:events:local:000000000000:event-bus/${name}`,
+        createdAt: new Date().toISOString()
+      });
+    }
+    return this.buses.get(name);
+  }
+
+  async putEvents(entries) {
+    const results = [];
+    for (const entry of entries) {
+      const eventId = Math.random().toString(36).substring(7);
+      this.events.push({
+        ...entry,
+        eventId,
+        time: new Date().toISOString(),
+        receivedAt: new Date().toISOString()
+      });
+      results.push({ EventId: eventId });
+      logger.verboso(`EventBridge: Event ${eventId} published to ${entry.EventBusName || 'default'}`);
+    }
+    return { Entries: results, FailedEntryCount: 0 };
+  }
+}
+
+module.exports = EventBridgeService;

package/src/services/index.js

@@ -0,0 +1,19 @@
+/**
+ * Barrel export para todos os serviços
+ */
+
+const DynamoDBService = require('./dynamodb');
+const S3Service = require('./s3');
+const SQSService = require('./sqs');
+const LambdaService = require('./lambda');
+const SNSService = require('./sns');
+const EventBridgeService = require('./eventbridge');
+
+module.exports = {
+  DynamoDBService,
+  S3Service,
+  SQSService,
+  LambdaService,
+  SNSService,
+  EventBridgeService
+};