@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/kinesis-firehose/simulator.js

@@ -0,0 +1,388 @@
+/**
+ * Kinesis Data Firehose Simulator
+ * Simulador de Kinesis Data Firehose com suporte a delivery streams e buffering
+ */
+
+const { DeliveryStream } = require('./models/delivery-stream');
+const LocalStore = require('../../utils/local-store');
+const logger = require('../../utils/logger');
+const path = require('path');
+const { CloudTrailAudit } = require('../../utils/cloudtrail-audit');
+const { v4: uuidv4 } = require('uuid');
+
+class KinesisFirehoseSimulator {
+  constructor(config) {
+    this.config = config;
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || './.aws-local-simulator-data';
+    this.dataDir = path.join(dataDir, 'kinesis-firehose');
+
+    this.store = new LocalStore(this.dataDir);
+    this.deliveryStreams = new Map();
+    this.audit = new CloudTrailAudit('firehose.amazonaws.com');
+
+    // Mutexes por stream para operações thread-safe
+    this._streamLocks = new Map();
+  }
+
+  /**
+   * Executa operação com lock exclusivo por stream
+   */
+  _withStreamLock(streamName, fn) {
+    const prev = this._streamLocks.get(streamName) || Promise.resolve();
+    const next = prev.then(() => fn());
+    this._streamLocks.set(streamName, next.catch(() => {}));
+    return next;
+  }
+
+  async initialize() {
+    logger.debug('Inicializando Kinesis Data Firehose Simulator...');
+    this.loadDeliveryStreams();
+
+    // Cria delivery streams da configuração
+    if (this.config['kinesis-firehose']?.deliveryStreams) {
+      for (const streamConfig of this.config['kinesis-firehose'].deliveryStreams) {
+        if (!this.deliveryStreams.has(streamConfig.name)) {
+          this.createDeliveryStream(streamConfig.name, streamConfig);
+        }
+      }
+    }
+
+    logger.debug(`✅ Kinesis Data Firehose Simulator inicializado com ${this.deliveryStreams.size} delivery streams`);
+  }
+
+  /**
+   * Carrega delivery streams persistidos
+   */
+  loadDeliveryStreams() {
+    const metadata = this.store.read('__delivery_streams__');
+    if (!metadata) return;
+
+    for (const [streamName, streamData] of Object.entries(metadata)) {
+      const stream = new DeliveryStream(streamName, streamData);
+      this.deliveryStreams.set(streamName, stream);
+    }
+
+    logger.debug(`Carregados ${this.deliveryStreams.size} delivery streams`);
+  }
+
+  /**
+   * Persiste metadados de delivery streams
+   */
+  persistDeliveryStreams() {
+    const metadata = {};
+
+    for (const [streamName, stream] of this.deliveryStreams) {
+      metadata[streamName] = stream.toJSON();
+    }
+
+    this.store.write('__delivery_streams__', metadata);
+  }
+
+  /**
+   * Cria um novo delivery stream
+   */
+  createDeliveryStream(deliveryStreamName, config = {}) {
+    if (this.deliveryStreams.has(deliveryStreamName)) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' already exists`);
+    }
+
+    const stream = new DeliveryStream(deliveryStreamName, config);
+
+    // Adiciona destinos (S3, HTTP, Redshift)
+    if (config.s3DestinationConfiguration) {
+      stream.addDestination({
+        type: 's3',
+        destinationId: uuidv4(),
+        arn: config.s3DestinationConfiguration.RoleArn,
+        bucketArn: config.s3DestinationConfiguration.BucketARN,
+        prefix: config.s3DestinationConfiguration.Prefix || '',
+        errorOutputPrefix: config.s3DestinationConfiguration.ErrorOutputPrefix || '',
+        bufferingHints: {
+          sizeInMBs: config.s3DestinationConfiguration.BufferingHints?.SizeInMBs || 128,
+          intervalInSeconds: config.s3DestinationConfiguration.BufferingHints?.IntervalInSeconds || 60
+        },
+        compressionFormat: config.s3DestinationConfiguration.CompressionFormat || 'UNCOMPRESSED',
+        destinationStatus: 'ACTIVE'
+      });
+    }
+
+    if (config.httpEndpointDestinationConfiguration) {
+      stream.addDestination({
+        type: 'http',
+        destinationId: uuidv4(),
+        url: config.httpEndpointDestinationConfiguration.EndpointConfiguration?.Url,
+        name: config.httpEndpointDestinationConfiguration.EndpointConfiguration?.Name,
+        roleArn: config.httpEndpointDestinationConfiguration.RoleARN,
+        bufferingHints: {
+          sizeInMBs: config.httpEndpointDestinationConfiguration.BufferingHints?.SizeInMBs || 128,
+          intervalInSeconds: config.httpEndpointDestinationConfiguration.BufferingHints?.IntervalInSeconds || 60
+        },
+        processingConfiguration: config.httpEndpointDestinationConfiguration.ProcessingConfiguration || null,
+        destinationStatus: 'ACTIVE'
+      });
+    }
+
+    if (config.redshiftDestinationConfiguration) {
+      stream.addDestination({
+        type: 'redshift',
+        destinationId: uuidv4(),
+        clusterArn: config.redshiftDestinationConfiguration.ClusterARN,
+        roleArn: config.redshiftDestinationConfiguration.RoleARN,
+        username: config.redshiftDestinationConfiguration.Username,
+        databaseName: config.redshiftDestinationConfiguration.DatabaseName,
+        tableName: config.redshiftDestinationConfiguration.TableName,
+        s3DestinationDescription: config.redshiftDestinationConfiguration.S3DestinationConfiguration,
+        destinationStatus: 'ACTIVE'
+      });
+    }
+
+    this.deliveryStreams.set(deliveryStreamName, stream);
+    this.persistDeliveryStreams();
+
+    this.audit.record({
+      eventName: 'CreateDeliveryStream',
+      readOnly: false,
+      resources: [{
+        ARN: stream.deliveryStreamArn,
+        type: 'AWS::Firehose::DeliveryStream'
+      }],
+      requestParameters: { deliveryStreamName }
+    });
+
+    logger.info(`✅ Delivery Stream criado: ${deliveryStreamName}`);
+
+    return {
+      DeliveryStreamArn: stream.deliveryStreamArn
+    };
+  }
+
+  /**
+   * Descreve um delivery stream
+   */
+  describeDeliveryStream(deliveryStreamName) {
+    const stream = this.deliveryStreams.get(deliveryStreamName);
+    if (!stream) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' not found`);
+    }
+
+    return stream.describe();
+  }
+
+  /**
+   * Lista delivery streams
+   */
+  listDeliveryStreams(params = {}) {
+    const { Limit = 100, ExclusiveStartDeliveryStreamName } = params;
+    const streamNames = Array.from(this.deliveryStreams.keys());
+
+    let startIndex = 0;
+    if (ExclusiveStartDeliveryStreamName) {
+      const index = streamNames.indexOf(ExclusiveStartDeliveryStreamName);
+      if (index !== -1) startIndex = index + 1;
+    }
+
+    const result = streamNames.slice(startIndex, startIndex + Limit);
+
+    return {
+      DeliveryStreamNames: result,
+      HasMoreDeliveryStreams: result.length === Limit
+    };
+  }
+
+  /**
+   * Deleta um delivery stream
+   */
+  deleteDeliveryStream(deliveryStreamName) {
+    const stream = this.deliveryStreams.get(deliveryStreamName);
+    if (!stream) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' not found`);
+    }
+
+    this.deliveryStreams.delete(deliveryStreamName);
+    this.persistDeliveryStreams();
+
+    this.audit.record({
+      eventName: 'DeleteDeliveryStream',
+      readOnly: false,
+      resources: [{
+        ARN: stream.deliveryStreamArn,
+        type: 'AWS::Firehose::DeliveryStream'
+      }],
+      requestParameters: { deliveryStreamName }
+    });
+
+    logger.info(`✅ Delivery Stream deletado: ${deliveryStreamName}`);
+
+    return {};
+  }
+
+  /**
+   * Coloca um record no delivery stream (PutRecord)
+   */
+  async putRecord(deliveryStreamName, record) {
+    const stream = this.deliveryStreams.get(deliveryStreamName);
+    if (!stream) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' not found`);
+    }
+
+    return this._withStreamLock(deliveryStreamName, () => {
+      const addedRecord = stream.addRecordToBuffer(record.Data);
+
+      this.persistDeliveryStreams();
+
+      this.audit.record({
+        eventName: 'PutRecord',
+        readOnly: false,
+        isDataEvent: true,
+        resources: [{
+          ARN: stream.deliveryStreamArn,
+          type: 'AWS::Firehose::DeliveryStream'
+        }],
+        requestParameters: { deliveryStreamName }
+      });
+
+      return {
+        RecordId: addedRecord.recordId,
+        Encrypted: false
+      };
+    });
+  }
+
+  /**
+   * Coloca múltiplos records no delivery stream (PutRecordBatch)
+   */
+  async putRecordBatch(deliveryStreamName, records) {
+    const stream = this.deliveryStreams.get(deliveryStreamName);
+    if (!stream) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' not found`);
+    }
+
+    return this._withStreamLock(deliveryStreamName, () => {
+      const results = [];
+      let failedCount = 0;
+
+      for (const record of records) {
+        try {
+          const addedRecord = stream.addRecordToBuffer(record.Data);
+          results.push({
+            RecordId: addedRecord.recordId,
+            ErrorCode: null,
+            ErrorMessage: null
+          });
+        } catch (error) {
+          failedCount++;
+          results.push({
+            RecordId: null,
+            ErrorCode: 'InternalFailure',
+            ErrorMessage: error.message
+          });
+        }
+      }
+
+      this.persistDeliveryStreams();
+
+      this.audit.record({
+        eventName: 'PutRecordBatch',
+        readOnly: false,
+        isDataEvent: true,
+        resources: [{
+          ARN: stream.deliveryStreamArn,
+          type: 'AWS::Firehose::DeliveryStream'
+        }],
+        requestParameters: { deliveryStreamName, recordCount: records.length }
+      });
+
+      return {
+        FailedPutCount: failedCount,
+        Encrypted: false,
+        Records: results
+      };
+    });
+  }
+
+  /**
+   * Obtém informações de destino
+   */
+  describeDestination(deliveryStreamName, destinationId) {
+    const stream = this.deliveryStreams.get(deliveryStreamName);
+    if (!stream) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' not found`);
+    }
+
+    const destination = stream.destinations.find(d => d.destinationId === destinationId);
+    if (!destination) {
+      throw new Error(`Destination '${destinationId}' not found`);
+    }
+
+    return {
+      DestinationDescription: destination
+    };
+  }
+
+  /**
+   * Atualiza delivery stream
+   */
+  updateDeliveryStream(deliveryStreamName, config) {
+    const stream = this.deliveryStreams.get(deliveryStreamName);
+    if (!stream) {
+      throw new Error(`DeliveryStream '${deliveryStreamName}' not found`);
+    }
+
+    // Atualiza configurações
+    if (config.deliveryStreamStatus) {
+      stream.deliveryStreamStatus = config.deliveryStreamStatus;
+    }
+
+    if (config.s3DestinationUpdate) {
+      const dest = stream.destinations[0];
+      if (dest && dest.type === 's3') {
+        Object.assign(dest, {
+          bufferingHints: config.s3DestinationUpdate.BufferingHints || dest.bufferingHints,
+          prefix: config.s3DestinationUpdate.Prefix || dest.prefix
+        });
+      }
+    }
+
+    stream.lastUpdateTimestamp = new Date().toISOString();
+    this.persistDeliveryStreams();
+
+    logger.info(`✅ Delivery Stream atualizado: ${deliveryStreamName}`);
+
+    return {};
+  }
+
+  /**
+   * Obtém estatísticas do simulator
+   */
+  getStats() {
+    const stats = {
+      deliveryStreamsCount: this.deliveryStreams.size,
+      totalRecords: 0,
+      totalDeliveredRecords: 0,
+      totalFailedRecords: 0,
+      deliveryStreams: []
+    };
+
+    for (const [streamName, stream] of this.deliveryStreams) {
+      const streamStats = stream.toJSON();
+      stats.totalRecords += streamStats.recordCount;
+      stats.totalDeliveredRecords += streamStats.deliveredRecordCount;
+      stats.totalFailedRecords += streamStats.failedDeliveryRecordCount;
+      stats.deliveryStreams.push(streamStats);
+    }
+
+    return stats;
+  }
+
+  /**
+   * Reset - limpa todos os dados
+   */
+  async reset() {
+    this.deliveryStreams.clear();
+    this.store.write('__delivery_streams__', {});
+
+    logger.info('✅ Kinesis Data Firehose Simulator resetado');
+  }
+}
+
+module.exports = KinesisFirehoseSimulator;

package/src/services/kinesis-firehose/store.js

@@ -0,0 +1,163 @@
+/**
+ * Kinesis Data Firehose Store - Persistência de delivery streams em JSON
+ */
+
+const path = require('path');
+const fs = require('fs');
+const logger = require('../../utils/logger');
+
+class KinesisFirehoseStore {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.streamsDir = path.join(dataDir, 'kinesis-firehose');
+    this.metadataFile = path.join(this.streamsDir, '__delivery_streams__.json');
+
+    if (!fs.existsSync(this.streamsDir)) {
+      fs.mkdirSync(this.streamsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Carrega metadados de todos os delivery streams
+   */
+  loadMetadata() {
+    if (fs.existsSync(this.metadataFile)) {
+      try {
+        const data = fs.readFileSync(this.metadataFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler ${this.metadataFile}: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva metadados de todos os delivery streams
+   */
+  saveMetadata(metadata) {
+    try {
+      fs.writeFileSync(this.metadataFile, JSON.stringify(metadata, null, 2), 'utf8');
+      logger.debug(`Metadados de delivery streams salvos em ${this.metadataFile}`);
+    } catch (error) {
+      logger.error(`Erro ao salvar ${this.metadataFile}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Obtém caminho do arquivo de delivery stream
+   */
+  getDeliveryStreamPath(deliveryStreamName) {
+    return path.join(this.streamsDir, `${deliveryStreamName}.json`);
+  }
+
+  /**
+   * Carrega records de um delivery stream
+   */
+  loadDeliveryStreamRecords(deliveryStreamName) {
+    const streamPath = this.getDeliveryStreamPath(deliveryStreamName);
+
+    if (!fs.existsSync(streamPath)) {
+      return [];
+    }
+
+    try {
+      const data = fs.readFileSync(streamPath, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      logger.warn(`Erro ao ler delivery stream ${deliveryStreamName}: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Salva records de um delivery stream
+   */
+  saveDeliveryStreamRecords(deliveryStreamName, records) {
+    try {
+      const streamPath = this.getDeliveryStreamPath(deliveryStreamName);
+      fs.writeFileSync(streamPath, JSON.stringify(records, null, 2), 'utf8');
+      logger.debug(`${records.length} records salvos no delivery stream ${deliveryStreamName}`);
+    } catch (error) {
+      logger.error(`Erro ao salvar delivery stream ${deliveryStreamName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Adiciona record ao delivery stream
+   */
+  addRecord(deliveryStreamName, record) {
+    const records = this.loadDeliveryStreamRecords(deliveryStreamName);
+    records.push(record);
+    this.saveDeliveryStreamRecords(deliveryStreamName, records);
+  }
+
+  /**
+   * Adiciona múltiplos records
+   */
+  addRecords(deliveryStreamName, newRecords) {
+    const records = this.loadDeliveryStreamRecords(deliveryStreamName);
+    records.push(...newRecords);
+    this.saveDeliveryStreamRecords(deliveryStreamName, records);
+  }
+
+  /**
+   * Remove record do delivery stream
+   */
+  removeRecord(deliveryStreamName, recordId) {
+    const records = this.loadDeliveryStreamRecords(deliveryStreamName);
+    const filtered = records.filter(r => r.recordId !== recordId);
+
+    if (filtered.length < records.length) {
+      this.saveDeliveryStreamRecords(deliveryStreamName, filtered);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Deleta delivery stream completamente
+   */
+  deleteDeliveryStream(deliveryStreamName) {
+    try {
+      const streamPath = this.getDeliveryStreamPath(deliveryStreamName);
+      if (fs.existsSync(streamPath)) {
+        fs.unlinkSync(streamPath);
+        logger.debug(`Delivery Stream ${deliveryStreamName} deletado`);
+      }
+    } catch (error) {
+      logger.error(`Erro ao deletar delivery stream ${deliveryStreamName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calcula tamanho total do delivery stream em bytes
+   */
+  getDeliveryStreamSize(deliveryStreamName) {
+    const records = this.loadDeliveryStreamRecords(deliveryStreamName);
+    return records.reduce((sum, record) => sum + Buffer.byteLength(JSON.stringify(record.data)), 0);
+  }
+
+  /**
+   * Limpa todos os delivery streams
+   */
+  clear() {
+    try {
+      if (fs.existsSync(this.streamsDir)) {
+        const files = fs.readdirSync(this.streamsDir);
+        files.forEach(file => {
+          if (file.endsWith('.json')) {
+            fs.unlinkSync(path.join(this.streamsDir, file));
+          }
+        });
+        logger.debug('Todos os delivery streams foram limpos');
+      }
+    } catch (error) {
+      logger.error(`Erro ao limpar delivery streams: ${error.message}`);
+    }
+  }
+}
+
+module.exports = KinesisFirehoseStore;

package/src/services/kms/server.js

@@ -1,10 +1,13 @@
+const { setupServiceMiddleware } = require('../../middleware');
 'use strict';
 
 const express = require('express');
 const cors = require('cors');
 
 class KMSServer {
-  constructor(simulator, logger, config) {
+  constructor(simulator, logger, config) {
+    this.organizationsService = null;
+    this.stsService = null;
     this.simulator = simulator;
     this.logger = logger;
     this.config = config;

package/src/services/lambda/handler-loader.js

@@ -146,9 +146,25 @@ class HandlerLoader {
    * Recarrega um handler (útil para hot reload)
    */
   static async reload(handlerPath, type = 'auto') {
-    // Limpa cache
-    const fullPath = path.resolve(process.cwd(), handlerPath);
-    delete require.cache[require.resolve(fullPath)];
+    // Resolve path: try cwd first, then data dir (same logic as load())
+    let fullPath = path.resolve(process.cwd(), handlerPath);
+
+    if (!fs.existsSync(fullPath)) {
+      const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+      if (dataDir) {
+        const dataPath = path.resolve(dataDir, 'lambda', handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          fullPath = dataPath;
+        }
+      }
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Handler não encontrado: ${fullPath}`);
+    }
+
+    // Limpa cache do require
+    delete require.cache[fullPath];
     
     // Recarrega
     return this.load(handlerPath, type);
@@ -158,7 +174,20 @@ class HandlerLoader {
    * Valida se um caminho de handler é válido
    */
   static isValid(handlerPath) {
-    const fullPath = path.resolve(process.cwd(), handlerPath);
+    // Tenta resolver de cwd primeiro
+    let fullPath = path.resolve(process.cwd(), handlerPath);
+    
+    if (!fs.existsSync(fullPath)) {
+      // Tenta resolver do data dir
+      const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+      if (dataDir) {
+        const dataPath = path.resolve(dataDir, 'lambda', handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          return true;
+        }
+      }
+    }
+    
     return fs.existsSync(fullPath);
   }
   
@@ -166,7 +195,23 @@ class HandlerLoader {
    * Retorna informações sobre o handler
    */
   static async getInfo(handlerPath) {
-    const fullPath = path.resolve(process.cwd(), handlerPath);
+    // Resolve path: try cwd first, then data dir (same logic as load())
+    let fullPath = path.resolve(process.cwd(), handlerPath);
+
+    if (!fs.existsSync(fullPath)) {
+      const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR;
+      if (dataDir) {
+        const dataPath = path.resolve(dataDir, 'lambda', handlerPath.replace(/^\.\//, ''));
+        if (fs.existsSync(dataPath)) {
+          fullPath = dataPath;
+        }
+      }
+    }
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`Handler não encontrado: ${fullPath}`);
+    }
+
     const type = this.detectType(fullPath);
     const stats = fs.statSync(fullPath);
     

package/src/services/lambda/index.js

@@ -39,6 +39,32 @@ class LambdaService {
 
     const cw = server.getService('cloudwatch');
     if (cw?.simulator) this.simulator.cloudwatchSimulator = cw.simulator;
+
+    // IAM enforcement middleware (only when IAM service is active)
+    const iamService = server.getService('iam');
+    if (iamService && iamService.getSimulator()) {
+      const { createIAMEnforcementMiddleware } = require('../iam/middleware');
+      const iamSimulator = iamService.getSimulator();
+      this.server.iamMiddleware = createIAMEnforcementMiddleware({
+        iamSimulator,
+        servicePrefix: 'lambda',
+        extractAction: (req) => {
+          if (req.path.includes('/invocations')) return 'InvokeFunction';
+          if (req.method === 'POST') return 'CreateFunction';
+          if (req.method === 'GET') return 'ListFunctions';
+          if (req.method === 'DELETE') return 'DeleteFunction';
+          if (req.method === 'PUT') return 'UpdateFunctionConfiguration';
+          return 'Unknown';
+        },
+        extractResource: (req) => {
+          const functionName = req.params?.functionName || req.path.split('/functions/')[1]?.split('/')[0] || 'unknown';
+          return `arn:aws:lambda:us-east-1:123456789012:function:${functionName}`;
+        },
+        formatError: (res, code, message) => {
+          res.status(403).json({ Message: message, Type: code });
+        }
+      });
+    }
   }
 
   async start() {