@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/aurora/db-engine.js

@@ -0,0 +1,270 @@
+'use strict';
+
+/**
+ * DB Engine - Gerencia múltiplas instâncias SQLite (uma por database lógico Aurora).
+ * Responsável por executar queries, gerenciar transações e ciclo de vida de conexões.
+ */
+
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+const logger = require('../../utils/logger');
+
+class DbEngine {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.databases = new Map(); // dbName → better-sqlite3 Database instance
+    this.transactions = new Map(); // transactionId → { db, dbName, startedAt }
+
+    // Ensure data directory exists
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  /**
+   * Gets or lazily creates a SQLite database file for the given database name.
+   * @param {string} dbName - Logical database name
+   * @returns {import('better-sqlite3').Database} The better-sqlite3 database instance
+   */
+  getOrCreateDatabase(dbName) {
+    if (this.databases.has(dbName)) {
+      return this.databases.get(dbName);
+    }
+
+    const dbPath = path.join(this.dataDir, `${dbName}.db`);
+    const db = new Database(dbPath);
+
+    // Performance optimizations
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+
+    this.databases.set(dbName, db);
+    logger.debug(`[Aurora DbEngine] Database '${dbName}' created/opened at ${dbPath}`);
+
+    return db;
+  }
+
+  /**
+   * Executes a SQL statement on the specified database.
+   * Detects statement type (SELECT, DML, DDL) and returns structured results.
+   * @param {string} dbName - Target database name
+   * @param {string} sql - SQL statement to execute
+   * @param {Array} params - Bound parameters
+   * @returns {{ type: string, rows?: Array, columns?: Array, changes?: number, lastInsertRowid?: number }}
+   */
+  execute(dbName, sql, params) {
+    const db = this.getOrCreateDatabase(dbName);
+    return this._executeOnDb(db, sql, params);
+  }
+
+  /**
+   * Begins a new transaction on the specified database.
+   * @param {string} dbName - Target database name
+   * @returns {string} Unique transaction ID (UUID)
+   */
+  beginTransaction(dbName) {
+    const db = this.getOrCreateDatabase(dbName);
+    const transactionId = crypto.randomUUID();
+
+    db.exec('BEGIN');
+
+    this.transactions.set(transactionId, {
+      db,
+      dbName,
+      startedAt: Date.now()
+    });
+
+    logger.debug(`[Aurora DbEngine] Transaction ${transactionId} started on '${dbName}'`);
+    return transactionId;
+  }
+
+  /**
+   * Executes a SQL statement within an active transaction.
+   * @param {string} transactionId - Active transaction ID
+   * @param {string} sql - SQL statement to execute
+   * @param {Array} params - Bound parameters
+   * @returns {{ type: string, rows?: Array, columns?: Array, changes?: number, lastInsertRowid?: number }}
+   */
+  executeInTransaction(transactionId, sql, params) {
+    const transaction = this.transactions.get(transactionId);
+    if (!transaction) {
+      throw new Error(`Transaction ${transactionId} is not found`);
+    }
+
+    return this._executeOnDb(transaction.db, sql, params);
+  }
+
+  /**
+   * Commits an active transaction.
+   * @param {string} transactionId - Transaction ID to commit
+   */
+  commit(transactionId) {
+    const transaction = this.transactions.get(transactionId);
+    if (!transaction) {
+      throw new Error(`Transaction ${transactionId} is not found`);
+    }
+
+    transaction.db.exec('COMMIT');
+    this.transactions.delete(transactionId);
+    logger.debug(`[Aurora DbEngine] Transaction ${transactionId} committed`);
+  }
+
+  /**
+   * Rolls back an active transaction.
+   * @param {string} transactionId - Transaction ID to rollback
+   */
+  rollback(transactionId) {
+    const transaction = this.transactions.get(transactionId);
+    if (!transaction) {
+      throw new Error(`Transaction ${transactionId} is not found`);
+    }
+
+    transaction.db.exec('ROLLBACK');
+    this.transactions.delete(transactionId);
+    logger.debug(`[Aurora DbEngine] Transaction ${transactionId} rolled back`);
+  }
+
+  /**
+   * Lists all existing databases (based on .db files in the data directory).
+   * @returns {string[]} Array of database names (without .db extension)
+   */
+  listDatabases() {
+    if (!fs.existsSync(this.dataDir)) {
+      return [];
+    }
+
+    return fs.readdirSync(this.dataDir)
+      .filter(file => file.endsWith('.db'))
+      .map(file => file.slice(0, -3));
+  }
+
+  /**
+   * Drops a database: closes connection and deletes the .db file.
+   * @param {string} dbName - Database name to drop
+   */
+  dropDatabase(dbName) {
+    // Close connection if open
+    if (this.databases.has(dbName)) {
+      const db = this.databases.get(dbName);
+      db.close();
+      this.databases.delete(dbName);
+    }
+
+    // Delete the .db file
+    const dbPath = path.join(this.dataDir, `${dbName}.db`);
+    if (fs.existsSync(dbPath)) {
+      fs.unlinkSync(dbPath);
+      logger.debug(`[Aurora DbEngine] Database '${dbName}' dropped`);
+    }
+  }
+
+  /**
+   * Closes all open SQLite connections and clears the databases Map.
+   */
+  close() {
+    for (const [dbName, db] of this.databases) {
+      try {
+        db.close();
+      } catch (err) {
+        logger.debug(`[Aurora DbEngine] Error closing database '${dbName}': ${err.message}`);
+      }
+    }
+    this.databases.clear();
+    this.transactions.clear();
+    logger.debug('[Aurora DbEngine] All connections closed');
+  }
+
+  /**
+   * Resets the engine: closes all connections and deletes all .db files.
+   */
+  reset() {
+    this.close();
+
+    // Delete all .db files in the data directory
+    if (fs.existsSync(this.dataDir)) {
+      const files = fs.readdirSync(this.dataDir).filter(f => f.endsWith('.db'));
+      for (const file of files) {
+        fs.unlinkSync(path.join(this.dataDir, file));
+      }
+    }
+
+    logger.debug('[Aurora DbEngine] Engine reset complete');
+  }
+
+  /**
+   * Internal: executes SQL on a given database instance, detecting statement type.
+   * @private
+   */
+  _executeOnDb(db, sql, params) {
+    const trimmed = sql.trim();
+    const upper = trimmed.toUpperCase();
+
+    // Detect statement type
+    if (upper.startsWith('SELECT') || upper.startsWith('PRAGMA') || upper.startsWith('EXPLAIN')) {
+      return this._executeSelect(db, trimmed, params);
+    } else if (
+      upper.startsWith('INSERT') ||
+      upper.startsWith('UPDATE') ||
+      upper.startsWith('DELETE') ||
+      upper.startsWith('REPLACE')
+    ) {
+      return this._executeDml(db, trimmed, params);
+    } else {
+      // DDL: CREATE, DROP, ALTER, etc.
+      return this._executeDdl(db, trimmed);
+    }
+  }
+
+  /**
+   * Executes a SELECT statement, returning rows and column metadata.
+   * @private
+   */
+  _executeSelect(db, sql, params) {
+    const stmt = db.prepare(sql);
+    const rows = stmt.all(...(params || []));
+    const columns = stmt.columns();
+
+    return {
+      type: 'select',
+      rows,
+      columns,
+      changes: 0,
+      lastInsertRowid: 0
+    };
+  }
+
+  /**
+   * Executes a DML statement (INSERT/UPDATE/DELETE), returning change count.
+   * @private
+   */
+  _executeDml(db, sql, params) {
+    const stmt = db.prepare(sql);
+    const result = stmt.run(...(params || []));
+
+    return {
+      type: 'dml',
+      rows: [],
+      columns: [],
+      changes: result.changes,
+      lastInsertRowid: Number(result.lastInsertRowid)
+    };
+  }
+
+  /**
+   * Executes a DDL statement (CREATE/DROP/ALTER), returning zero changes.
+   * @private
+   */
+  _executeDdl(db, sql) {
+    db.exec(sql);
+
+    return {
+      type: 'ddl',
+      rows: [],
+      columns: [],
+      changes: 0,
+      lastInsertRowid: 0
+    };
+  }
+}
+
+module.exports = { DbEngine };

package/src/services/aurora/index.js

@@ -0,0 +1,159 @@
+'use strict';
+
+/**
+ * Aurora Service - Ponto de entrada
+ * Simula Amazon Aurora (MySQL/PostgreSQL-compatible) via Data API e RDS Management API.
+ * Porta padrão: 4510
+ */
+
+const path = require('path');
+const AuroraServer = require('./server');
+const { DbEngine } = require('./db-engine');
+const { ClusterManager } = require('./cluster-manager');
+const { DataApiHandler } = require('./data-api');
+const { RdsApiHandler } = require('./rds-api');
+const LocalStore = require('../../utils/local-store');
+
+class AuroraService {
+  constructor(config) {
+    this.config = config;
+    this.name = 'aurora';
+    this.port = config?.ports?.aurora || 4510;
+    this.server = null;
+    this.dbEngine = null;
+    this.clusterManager = null;
+    this.dataApiHandler = null;
+    this.rdsApiHandler = null;
+    this.isRunning = false;
+
+    // Dependencies injected later via injectDependencies()
+    this.kmsService = null;
+    this.secretManagerService = null;
+    this.cloudTrailService = null;
+    this.cloudWatchService = null;
+  }
+
+  async initialize() {
+    const logger = require('../../utils/logger');
+    logger.debug(`Inicializando Aurora Service na porta ${this.port}...`);
+
+    // Data directory for SQLite files
+    const dataDir = path.join(this.config.dataDir || './data', 'aurora');
+
+    // Create LocalStore for JSON persistence
+    const store = new LocalStore(dataDir);
+
+    // 1. Create core components
+    this.dbEngine = new DbEngine(dataDir);
+    this.clusterManager = new ClusterManager(dataDir, store);
+    this.clusterManager.initialize();
+
+    // 2. Create handlers with dependencies
+    this.dataApiHandler = new DataApiHandler(this.dbEngine, null, this.clusterManager, logger);
+    this.rdsApiHandler = new RdsApiHandler(this.clusterManager, this.dbEngine, logger);
+
+    // 3. Create server and wire handlers
+    this.server = new AuroraServer(this.port, this.config);
+    this.server.dataApiHandler = this.dataApiHandler;
+    this.server.rdsApiHandler = this.rdsApiHandler;
+    this.server.clusterManager = this.clusterManager;
+    this.server.dbEngine = this.dbEngine;
+    await this.server.initialize();
+
+    logger.debug('Aurora Service inicializado');
+  }
+
+  injectDependencies(server) {
+    const kms = server.getService('kms');
+    if (kms?.simulator) {
+      this.kmsService = kms.simulator;
+      if (this.rdsApiHandler) this.rdsApiHandler.kmsService = this.kmsService;
+    }
+
+    const secretManager = server.getService('secret-manager');
+    if (secretManager?.simulator) {
+      this.secretManagerService = secretManager.simulator;
+      if (this.dataApiHandler) this.dataApiHandler.secretManagerService = this.secretManagerService;
+    }
+
+    const cloudTrail = server.getService('cloudtrail');
+    if (cloudTrail?.simulator) {
+      this.cloudTrailService = cloudTrail.simulator;
+      if (this.rdsApiHandler) this.rdsApiHandler.cloudTrailService = this.cloudTrailService;
+      if (this.dataApiHandler) this.dataApiHandler.cloudTrailService = this.cloudTrailService;
+    }
+
+    const cloudWatch = server.getService('cloudwatch');
+    if (cloudWatch?.simulator) {
+      this.cloudWatchService = cloudWatch.simulator;
+      if (this.dataApiHandler) this.dataApiHandler.cloudWatchService = this.cloudWatchService;
+    }
+  }
+
+  async start() {
+    if (this.isRunning) return;
+    await this.server.start();
+    this.isRunning = true;
+  }
+
+  async stop() {
+    if (!this.isRunning) return;
+    await this.server.stop();
+    if (this.dbEngine) this.dbEngine.close();
+    if (this.clusterManager?.metaDb) {
+      this.clusterManager.metaDb.close();
+      this.clusterManager.metaDb = null;
+    }
+    this.isRunning = false;
+  }
+
+  async reset() {
+    // Reset cluster metadata first (clears rows but keeps metaDb open)
+    if (this.clusterManager) {
+      this.clusterManager.reset();
+      // Also clear the JSON persistence file
+      const dataDir = path.join(this.config.dataDir || './data', 'aurora');
+      const store = new LocalStore(dataDir);
+      store.delete('__aurora__');
+    }
+    // Close all user database connections and delete their files
+    if (this.dbEngine) {
+      this.dbEngine.close();
+      // Remove only databases managed by DbEngine (not metadata.db)
+      const fs = require('fs');
+      const dataDir = this.dbEngine.dataDir;
+      if (fs.existsSync(dataDir)) {
+        const files = fs.readdirSync(dataDir).filter(f => f.endsWith('.db') && f !== 'metadata.db');
+        for (const file of files) {
+          fs.unlinkSync(path.join(dataDir, file));
+        }
+      }
+    }
+  }
+
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`,
+      clusters: this.clusterManager?.listClusters?.()?.length || 0,
+      databases: this.dbEngine?.listDatabases?.()?.length || 0,
+      activeTransactions: this.dataApiHandler?.transactions?.size || 0
+    };
+  }
+
+  getSimulator() {
+    return {
+      dataApiHandler: this.dataApiHandler,
+      rdsApiHandler: this.rdsApiHandler,
+      clusterManager: this.clusterManager,
+      dbEngine: this.dbEngine
+    };
+  }
+
+  getServer() {
+    return this.server;
+  }
+}
+
+module.exports = { AuroraService };

package/src/services/aurora/rds-api.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * RDS Management API Handler - Simula operações de gerenciamento RDS
+ * (CreateDBCluster, DeleteDBCluster, DescribeDBClusters, CreateDBInstance,
+ *  DeleteDBInstance, DescribeDBInstances, ModifyDBCluster, StopDBCluster, StartDBCluster)
+ */
+
+const logger = require('../../utils/logger');
+
+class RdsApiHandler {
+  constructor(clusterManager, dbEngine, log) {
+    this.clusterManager = clusterManager;
+    this.dbEngine = dbEngine;
+    this.logger = log || logger;
+
+    // Optional service dependencies (injected later)
+    this.kmsService = null;
+    this.cloudTrailService = null;
+  }
+
+  /**
+   * Routes an incoming RDS API action to the appropriate handler method.
+   * @param {string} action - The RDS API action name
+   * @param {Object} body - The request body/parameters
+   * @returns {Object} The response object
+   */
+  async handleRequest(action, body) {
+    switch (action) {
+      case 'CreateDBCluster': return this.createDBCluster(body);
+      case 'DeleteDBCluster': return this.deleteDBCluster(body);
+      case 'DescribeDBClusters': return this.describeDBClusters(body);
+      case 'CreateDBInstance': return this.createDBInstance(body);
+      case 'DeleteDBInstance': return this.deleteDBInstance(body);
+      case 'DescribeDBInstances': return this.describeDBInstances(body);
+      case 'ModifyDBCluster': return this.modifyDBCluster(body);
+      case 'StopDBCluster': return this.stopDBCluster(body);
+      case 'StartDBCluster': return this.startDBCluster(body);
+      default: {
+        const error = new Error(`Unknown action: ${action}`);
+        error.code = 'InvalidAction';
+        error.statusCode = 400;
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Creates a new Aurora DB cluster.
+   * Validates KMS key if StorageEncrypted, creates logical database if DatabaseName provided.
+   * Records CloudTrail event.
+   */
+  async createDBCluster(params) {
+    // Validate KMS key if StorageEncrypted and KmsKeyId provided
+    if (params.StorageEncrypted && params.KmsKeyId && this.kmsService) {
+      try {
+        await this.kmsService.describeKey({ KeyId: params.KmsKeyId });
+      } catch (err) {
+        const error = new Error(`KMS key not found or invalid: ${params.KmsKeyId}`);
+        error.code = 'InvalidParameterValue';
+        error.statusCode = 400;
+        throw error;
+      }
+    }
+
+    // Create via ClusterManager (handles all validation)
+    const cluster = this.clusterManager.createCluster(params);
+
+    // If DatabaseName is provided, ensure the database exists in DbEngine
+    if (params.DatabaseName && this.dbEngine) {
+      this.dbEngine.getOrCreateDatabase(params.DatabaseName);
+    }
+
+    // Record CloudTrail event
+    this._recordEvent('CreateDBCluster', params.DBClusterIdentifier);
+
+    return { DBCluster: cluster };
+  }
+
+  /**
+   * Deletes an existing Aurora DB cluster.
+   * Throws DBClusterNotFoundFault if cluster does not exist.
+   */
+  async deleteDBCluster(params) {
+    const { DBClusterIdentifier } = params;
+    this.clusterManager.deleteCluster(DBClusterIdentifier);
+    this._recordEvent('DeleteDBCluster', DBClusterIdentifier);
+    return {};
+  }
+
+  /**
+   * Describes one or all Aurora DB clusters.
+   * Returns all clusters when no filter, or a specific one by DBClusterIdentifier.
+   */
+  async describeDBClusters(params) {
+    const { DBClusterIdentifier } = params || {};
+    const filters = DBClusterIdentifier ? { DBClusterIdentifier } : undefined;
+    const clusters = this.clusterManager.listClusters(filters);
+    return { DBClusters: clusters };
+  }
+
+  /**
+   * Creates a new Aurora DB instance within an existing cluster.
+   * Records CloudTrail event.
+   */
+  async createDBInstance(params) {
+    const instance = this.clusterManager.createInstance(params);
+    this._recordEvent('CreateDBInstance', params.DBInstanceIdentifier);
+    return { DBInstance: instance };
+  }
+
+  /**
+   * Deletes an existing Aurora DB instance.
+   * Throws DBInstanceNotFoundFault if instance does not exist.
+   */
+  async deleteDBInstance(params) {
+    const { DBInstanceIdentifier } = params;
+    this.clusterManager.deleteInstance(DBInstanceIdentifier);
+    this._recordEvent('DeleteDBInstance', DBInstanceIdentifier);
+    return {};
+  }
+
+  /**
+   * Describes one or all Aurora DB instances.
+   * Returns all instances when no filter, or a specific one by DBInstanceIdentifier.
+   */
+  async describeDBInstances(params) {
+    const { DBInstanceIdentifier } = params || {};
+    const filters = DBInstanceIdentifier ? { DBInstanceIdentifier } : undefined;
+    const instances = this.clusterManager.listInstances(filters);
+    return { DBInstances: instances };
+  }
+
+  /**
+   * Modifies an existing Aurora DB cluster's fields.
+   * Records CloudTrail event.
+   */
+  async modifyDBCluster(params) {
+    const { DBClusterIdentifier, ...fields } = params;
+    const cluster = this.clusterManager.updateCluster(DBClusterIdentifier, fields);
+    this._recordEvent('ModifyDBCluster', DBClusterIdentifier);
+    return { DBCluster: cluster };
+  }
+
+  /**
+   * Stops an Aurora DB cluster (changes status to 'stopped').
+   * Records CloudTrail event.
+   */
+  async stopDBCluster(params) {
+    const { DBClusterIdentifier } = params;
+    const cluster = this.clusterManager.updateCluster(DBClusterIdentifier, { Status: 'stopped' });
+    this._recordEvent('StopDBCluster', DBClusterIdentifier);
+    return { DBCluster: cluster };
+  }
+
+  /**
+   * Starts a stopped Aurora DB cluster (changes status to 'available').
+   * Records CloudTrail event.
+   */
+  async startDBCluster(params) {
+    const { DBClusterIdentifier } = params;
+    const cluster = this.clusterManager.updateCluster(DBClusterIdentifier, { Status: 'available' });
+    this._recordEvent('StartDBCluster', DBClusterIdentifier);
+    return { DBCluster: cluster };
+  }
+
+  /**
+   * Records a CloudTrail event for an RDS Management API operation.
+   * Silently fails if CloudTrail service is unavailable or throws.
+   * @private
+   */
+  _recordEvent(eventName, resourceId) {
+    if (this.cloudTrailService) {
+      try {
+        this.cloudTrailService.recordEvent({
+          eventSource: 'rds.amazonaws.com',
+          eventName,
+          resources: [{ ResourceType: 'AWS::RDS::DBCluster', ResourceName: resourceId || 'unknown' }],
+          requestParameters: { dBClusterIdentifier: resourceId || 'unknown' }
+        });
+      } catch (e) {
+        // Don't fail the request if CloudTrail recording fails
+        this.logger.debug(`[Aurora RdsApiHandler] CloudTrail recording failed: ${e.message}`);
+      }
+    }
+  }
+}
+
+module.exports = { RdsApiHandler };