@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/aurora/server.js

@@ -0,0 +1,213 @@
+'use strict';
+
+/**
+ * Aurora Server - HTTP server que roteia requisições para Data API ou RDS Management API.
+ * 
+ * Routing:
+ * - x-amz-target header starting with "RDSDataService" → Data API Handler
+ * - Body/query Action parameter → RDS Management API Handler
+ * - Otherwise → HTTP 400
+ * 
+ * Admin endpoints:
+ * - GET /__admin/health
+ * - GET /__admin/clusters
+ * - GET /__admin/databases
+ * - POST /__admin/reset
+ */
+
+const express = require('express');
+const cors = require('cors');
+const logger = require('../../utils/logger');
+
+class AuroraServer {
+  constructor(port, config) {
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.server = null;
+
+    // Handler/manager references set externally by AuroraService
+    this.dataApiHandler = null;
+    this.rdsApiHandler = null;
+    this.clusterManager = null;
+    this.dbEngine = null;
+
+    this.setupMiddlewares();
+  }
+
+  setupMiddlewares() {
+    this.app.use(cors());
+    this.app.use(express.json({
+      type: (req) => {
+        const ct = req.headers['content-type'] || '';
+        return ct.includes('application/x-amz-json-1.1') || ct.includes('application/json');
+      }
+    }));
+
+    // Request logging
+    if (logger.currentLogLevel === 'verboso') {
+      this.app.use((req, res, next) => {
+        const start = Date.now();
+        res.on('finish', () => {
+          const duration = Date.now() - start;
+          const target = req.headers['x-amz-target'] || '';
+          const action = req.body?.Action || '';
+          logger.verboso(`Aurora: ${target || action || req.method} - ${duration}ms`);
+        });
+        next();
+      });
+    }
+  }
+
+  async initialize() {
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // Main endpoint - route based on headers/body
+    this.app.post('/', async (req, res) => {
+      const target = req.headers['x-amz-target'] || '';
+      const body = req.body || {};
+      const action = body.Action || req.query?.Action || '';
+
+      try {
+        let result;
+
+        if (target.startsWith('RDSDataService')) {
+          // Data API routing
+          if (!this.dataApiHandler) {
+            return res.status(503).json({
+              __type: 'ServiceUnavailableException',
+              message: 'Data API handler not initialized'
+            });
+          }
+          result = await this.dataApiHandler.handleRequest(target, body);
+        } else if (action) {
+          // RDS Management API routing
+          if (!this.rdsApiHandler) {
+            return res.status(503).json({
+              __type: 'ServiceUnavailableException',
+              message: 'RDS API handler not initialized'
+            });
+          }
+          result = await this.rdsApiHandler.handleRequest(action, body);
+        } else {
+          // Unrecognized request
+          return res.status(400).json({
+            __type: 'BadRequestException',
+            message: 'Unrecognized request. Expected x-amz-target header starting with "RDSDataService" or an Action parameter.'
+          });
+        }
+
+        res.json(result || {});
+      } catch (error) {
+        logger.error(`Aurora Error: ${error.message}`);
+
+        // If error already has an AWS-style code, use it directly
+        if (error.code && error.statusCode) {
+          return res.status(error.statusCode).json({
+            __type: error.code,
+            message: error.message
+          });
+        }
+
+        // Wrap raw SQLite/better-sqlite3 errors as BadRequestException
+        // These come from db.prepare(), stmt.run(), stmt.all(), etc.
+        if (error.message && (
+          error.message.includes('SQLITE_') ||
+          error.message.includes('no such table') ||
+          error.message.includes('no such column') ||
+          error.message.includes('near "') ||
+          error.message.includes('syntax error') ||
+          error.constructor?.name === 'SqliteError'
+        )) {
+          return res.status(400).json({
+            __type: 'BadRequestException',
+            message: error.message
+          });
+        }
+
+        // Default: treat unstructured errors as BadRequestException (matching AWS behavior)
+        const statusCode = error.statusCode || 400;
+        res.status(statusCode).json({
+          __type: error.code || 'BadRequestException',
+          message: error.message
+        });
+      }
+    });
+
+    // Admin endpoints
+    this.setupAdminRoutes();
+  }
+
+  setupAdminRoutes() {
+    this.app.get('/__admin/health', (req, res) => {
+      res.json({
+        status: 'healthy',
+        service: 'aurora',
+        port: this.port,
+        running: !!this.server
+      });
+    });
+
+    this.app.get('/__admin/clusters', (req, res) => {
+      try {
+        const clusters = this.clusterManager ? this.clusterManager.listClusters() : [];
+        res.json({ clusters });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    this.app.get('/__admin/databases', (req, res) => {
+      try {
+        const databases = this.dbEngine ? this.dbEngine.listDatabases() : [];
+        res.json({ databases });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    this.app.post('/__admin/reset', async (req, res) => {
+      try {
+        if (this.clusterManager) await this.clusterManager.reset();
+        if (this.dbEngine) await this.dbEngine.reset();
+        res.json({ message: 'Aurora data reset complete' });
+      } catch (error) {
+        res.status(500).json({ error: error.message });
+      }
+    });
+  }
+
+  start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`🌐 Aurora rodando em http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          this.server = null;
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  getStatus() {
+    return {
+      running: !!this.server,
+      port: this.port,
+      endpoint: `http://localhost:${this.port}`
+    };
+  }
+}
+
+module.exports = AuroraServer;

package/src/services/aurora/sql-translator.js

@@ -0,0 +1,334 @@
+'use strict';
+
+/**
+ * SQL Translator - Converte SQL MySQL/PostgreSQL para SQLite compatível.
+ * 
+ * Responsabilidades:
+ * - Conversão de tipos de dados (VARCHAR→TEXT, INT→INTEGER, DOUBLE→REAL, etc.)
+ * - Tradução de funções (NOW()→datetime('now'), UUID()→hex expression)
+ * - Remoção de cláusulas não-suportadas (ENGINE, CHARSET, COLLATE, COMMENT)
+ * - Substituição AUTO_INCREMENT→AUTOINCREMENT
+ * - Normalização de whitespace e remoção de comentários
+ * 
+ * IMPORTANTE: O método translate() NÃO muta a string SQL original.
+ */
+
+class SqlTranslator {
+  /**
+   * @param {string} engineMode - 'aurora-mysql' | 'aurora-postgresql'
+   */
+  constructor(engineMode) {
+    if (engineMode !== 'aurora-mysql' && engineMode !== 'aurora-postgresql') {
+      throw new Error(`Invalid engineMode: ${engineMode}. Must be 'aurora-mysql' or 'aurora-postgresql'`);
+    }
+    this.engineMode = engineMode;
+  }
+
+  /**
+   * Translates SQL from MySQL/PostgreSQL dialect to SQLite-compatible SQL.
+   * Does NOT mutate the original SQL string.
+   * 
+   * @param {string} sql - Original SQL statement
+   * @returns {string} SQLite-compatible SQL
+   */
+  translate(sql) {
+    if (!sql || typeof sql !== 'string') {
+      return sql;
+    }
+
+    // Work on a copy - never mutate the original
+    let result = sql.trim();
+
+    // Step 1: Normalize whitespace and remove comments
+    result = this._removeComments(result);
+    result = this._normalizeWhitespace(result);
+
+    // Step 2: Translate data types (only in DDL context)
+    result = this._translateDataTypes(result);
+
+    // Step 3: Translate AUTO_INCREMENT
+    if (this.engineMode === 'aurora-mysql') {
+      result = result.replace(/\bAUTO_INCREMENT\b/gi, 'AUTOINCREMENT');
+    }
+
+    // Step 4: Remove engine-specific clauses
+    result = this._removeEngineClauses(result);
+
+    // Step 5: Translate functions (apply globally)
+    result = this._translateFunctions(result);
+
+    // Step 6: Translate ON CONFLICT (PostgreSQL only)
+    if (this.engineMode === 'aurora-postgresql') {
+      result = this._translateOnConflict(result);
+    }
+
+    return result;
+  }
+
+  /**
+   * Remove SQL comments (single-line -- and multi-line /* *\/)
+   * @private
+   */
+  _removeComments(sql) {
+    // Remove multi-line comments /* ... */
+    let result = sql.replace(/\/\*[\s\S]*?\*\//g, '');
+    // Remove single-line comments -- ...
+    result = result.replace(/--[^\n]*/g, '');
+    return result;
+  }
+
+  /**
+   * Normalize whitespace: collapse multiple spaces/tabs/newlines into single space
+   * @private
+   */
+  _normalizeWhitespace(sql) {
+    return sql.replace(/\s+/g, ' ').trim();
+  }
+
+  /**
+   * Translate MySQL/PostgreSQL data types to SQLite equivalents.
+   * Only applies within CREATE TABLE statements to avoid replacing data in DML.
+   * @private
+   */
+  _translateDataTypes(sql) {
+    if (this.engineMode === 'aurora-postgresql') {
+      return this._translatePostgresDataTypes(sql);
+    }
+
+    if (this.engineMode !== 'aurora-mysql') {
+      return sql;
+    }
+
+    // Check if this is a CREATE TABLE statement
+    if (!/\bCREATE\s+TABLE\b/i.test(sql)) {
+      return sql;
+    }
+
+    let result = sql;
+
+    // VARCHAR(N), CHAR(N) → TEXT
+    result = result.replace(/\bVARCHAR\s*\(\s*\d+\s*\)/gi, 'TEXT');
+    result = result.replace(/\bCHAR\s*\(\s*\d+\s*\)/gi, 'TEXT');
+
+    // TINYTEXT, MEDIUMTEXT, LONGTEXT → TEXT
+    result = result.replace(/\bTINYTEXT\b/gi, 'TEXT');
+    result = result.replace(/\bMEDIUMTEXT\b/gi, 'TEXT');
+    result = result.replace(/\bLONGTEXT\b/gi, 'TEXT');
+
+    // TINYINT, SMALLINT, MEDIUMINT → INTEGER (before INT to avoid partial match)
+    result = result.replace(/\bTINYINT\b/gi, 'INTEGER');
+    result = result.replace(/\bSMALLINT\b/gi, 'INTEGER');
+    result = result.replace(/\bMEDIUMINT\b/gi, 'INTEGER');
+
+    // BIGINT → INTEGER (before INT to avoid partial match)
+    result = result.replace(/\bBIGINT\b/gi, 'INTEGER');
+
+    // INT → INTEGER (word boundary prevents matching TINYINT, BIGINT, etc.)
+    result = result.replace(/\bINT\b/gi, 'INTEGER');
+
+    // FLOAT → REAL
+    result = result.replace(/\bFLOAT\b/gi, 'REAL');
+
+    // DOUBLE → REAL
+    result = result.replace(/\bDOUBLE\b/gi, 'REAL');
+
+    // DECIMAL(N,M) → REAL
+    result = result.replace(/\bDECIMAL\s*\(\s*\d+\s*,\s*\d+\s*\)/gi, 'REAL');
+
+    // DATETIME → TEXT
+    result = result.replace(/\bDATETIME\b/gi, 'TEXT');
+
+    // TIMESTAMP → TEXT
+    result = result.replace(/\bTIMESTAMP\b/gi, 'TEXT');
+
+    // DATE → TEXT (word boundary avoids matching CURDATE, DATETIME, etc.)
+    result = result.replace(/\bDATE\b/gi, 'TEXT');
+
+    // TIME → TEXT (word boundary avoids matching DATETIME, TIMESTAMP, etc.)
+    result = result.replace(/\bTIME\b/gi, 'TEXT');
+
+    // JSON → TEXT
+    result = result.replace(/\bJSON\b/gi, 'TEXT');
+
+    // TINYBLOB, MEDIUMBLOB, LONGBLOB → BLOB (before BLOB)
+    result = result.replace(/\bTINYBLOB\b/gi, 'BLOB');
+    result = result.replace(/\bMEDIUMBLOB\b/gi, 'BLOB');
+    result = result.replace(/\bLONGBLOB\b/gi, 'BLOB');
+
+    // BLOB → BLOB (already correct, but normalize case)
+    result = result.replace(/\bBLOB\b/gi, 'BLOB');
+
+    // ENUM(...) → TEXT
+    result = result.replace(/\bENUM\s*\([^)]*\)/gi, 'TEXT');
+
+    // SET(...) → TEXT
+    result = result.replace(/\bSET\s*\([^)]*\)/gi, 'TEXT');
+
+    return result;
+  }
+
+  /**
+   * Remove engine-specific clauses (ENGINE, CHARSET, COLLATE, CHARACTER SET, COMMENT)
+   * @private
+   */
+  _removeEngineClauses(sql) {
+    let result = sql;
+
+    // ENGINE=InnoDB (or any engine name)
+    result = result.replace(/\s*ENGINE\s*=\s*\w+/gi, '');
+
+    // DEFAULT CHARSET=utf8mb4 (or any charset)
+    result = result.replace(/\s*DEFAULT\s+CHARSET\s*=\s*\w+/gi, '');
+
+    // COLLATE = utf8mb4_unicode_ci or COLLATE utf8mb4_unicode_ci
+    result = result.replace(/\s*COLLATE\s*=?\s*\w+/gi, '');
+
+    // CHARACTER SET utf8
+    result = result.replace(/\s*CHARACTER\s+SET\s+\w+/gi, '');
+
+    // COMMENT 'text'
+    result = result.replace(/\s*COMMENT\s+'[^']*'/gi, '');
+
+    return result;
+  }
+
+  /**
+   * Translate MySQL/PostgreSQL functions to SQLite equivalents.
+   * Applied globally (not just in DDL).
+   * @private
+   */
+  _translateFunctions(sql) {
+    if (this.engineMode === 'aurora-postgresql') {
+      return this._translatePostgresFunctions(sql);
+    }
+
+    if (this.engineMode !== 'aurora-mysql') {
+      return sql;
+    }
+
+    let result = sql;
+
+    // NOW() → datetime('now')
+    result = result.replace(/\bNOW\s*\(\s*\)/gi, "datetime('now')");
+
+    // CURDATE() → date('now')
+    result = result.replace(/\bCURDATE\s*\(\s*\)/gi, "date('now')");
+
+    // CURTIME() → time('now')
+    result = result.replace(/\bCURTIME\s*\(\s*\)/gi, "time('now')");
+
+    // UUID() → lower(hex(randomblob(4))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(6)))
+    result = result.replace(
+      /\bUUID\s*\(\s*\)/gi,
+      "lower(hex(randomblob(4))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(6)))"
+    );
+
+    return result;
+  }
+
+  /**
+   * Translate PostgreSQL data types to SQLite equivalents.
+   * Only applies within CREATE TABLE statements to avoid replacing data in DML.
+   * @private
+   */
+  _translatePostgresDataTypes(sql) {
+    // Check if this is a CREATE TABLE statement
+    if (!/\bCREATE\s+TABLE\b/i.test(sql)) {
+      return sql;
+    }
+
+    let result = sql;
+
+    // BIGSERIAL → INTEGER PRIMARY KEY AUTOINCREMENT (before SERIAL to avoid partial match)
+    result = result.replace(/\bBIGSERIAL\b/gi, 'INTEGER PRIMARY KEY AUTOINCREMENT');
+
+    // SERIAL → INTEGER PRIMARY KEY AUTOINCREMENT
+    result = result.replace(/\bSERIAL\b/gi, 'INTEGER PRIMARY KEY AUTOINCREMENT');
+
+    // JSONB → TEXT (before JSON to avoid partial match)
+    result = result.replace(/\bJSONB\b/gi, 'TEXT');
+
+    // JSON → TEXT
+    result = result.replace(/\bJSON\b/gi, 'TEXT');
+
+    // BYTEA → BLOB
+    result = result.replace(/\bBYTEA\b/gi, 'BLOB');
+
+    // TIMESTAMPTZ → TEXT (before TIMESTAMP to avoid partial match)
+    result = result.replace(/\bTIMESTAMPTZ\b/gi, 'TEXT');
+
+    // TIMESTAMP → TEXT
+    result = result.replace(/\bTIMESTAMP\b/gi, 'TEXT');
+
+    // VARCHAR(N) → TEXT
+    result = result.replace(/\bVARCHAR\s*\(\s*\d+\s*\)/gi, 'TEXT');
+
+    // CHAR(N) → TEXT
+    result = result.replace(/\bCHAR\s*\(\s*\d+\s*\)/gi, 'TEXT');
+
+    // BOOLEAN → INTEGER
+    result = result.replace(/\bBOOLEAN\b/gi, 'INTEGER');
+
+    // NUMERIC(N,M) → REAL
+    result = result.replace(/\bNUMERIC\s*\(\s*\d+\s*,\s*\d+\s*\)/gi, 'REAL');
+
+    // DOUBLE PRECISION → REAL (before FLOAT to avoid conflicts)
+    result = result.replace(/\bDOUBLE\s+PRECISION\b/gi, 'REAL');
+
+    // FLOAT → REAL
+    result = result.replace(/\bFLOAT\b/gi, 'REAL');
+
+    // TEXT[] → TEXT (arrays stored as JSON text)
+    result = result.replace(/\bTEXT\s*\[\s*\]/gi, 'TEXT');
+
+    return result;
+  }
+
+  /**
+   * Translate PostgreSQL functions to SQLite equivalents.
+   * Applied globally (not just in DDL).
+   * @private
+   */
+  _translatePostgresFunctions(sql) {
+    let result = sql;
+
+    // NOW() → datetime('now')
+    result = result.replace(/\bNOW\s*\(\s*\)/gi, "datetime('now')");
+
+    // CURRENT_TIMESTAMP → datetime('now') (without parentheses - it's a keyword in PostgreSQL)
+    result = result.replace(/\bCURRENT_TIMESTAMP\b/gi, "datetime('now')");
+
+    // gen_random_uuid() → lower(hex(randomblob(4))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(6)))
+    result = result.replace(
+      /\bgen_random_uuid\s*\(\s*\)/gi,
+      "lower(hex(randomblob(4))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(2))||'-'||hex(randomblob(6)))"
+    );
+
+    // COALESCE is already SQLite-compatible, no translation needed
+
+    return result;
+  }
+
+  /**
+   * Translate PostgreSQL ON CONFLICT clauses to SQLite INSERT OR REPLACE/IGNORE.
+   * This is a simplification for the local simulator.
+   * @private
+   */
+  _translateOnConflict(sql) {
+    // ON CONFLICT (...) DO NOTHING → INSERT OR IGNORE INTO ...
+    let result = sql.replace(
+      /\bINSERT\s+INTO\b(.*?)\bON\s+CONFLICT\s*\([^)]*\)\s*DO\s+NOTHING\b/gi,
+      'INSERT OR IGNORE INTO$1'
+    );
+
+    // ON CONFLICT (...) DO UPDATE SET ... → INSERT OR REPLACE INTO ...
+    result = result.replace(
+      /\bINSERT\s+INTO\b(.*?)\bON\s+CONFLICT\s*\([^)]*\)\s*DO\s+UPDATE\s+SET\b[^;]*/gi,
+      'INSERT OR REPLACE INTO$1'
+    );
+
+    return result;
+  }
+}
+
+module.exports = SqlTranslator;

package/src/services/cloudformation/index.js

@@ -2,7 +2,7 @@
 
 /**
  * @fileoverview CloudFormation Service
- * Porta padrão: 4580
+ * Porta padrão: 4582
  */
 
 const http = require('http');
@@ -16,7 +16,7 @@ class CloudFormationService {
     this.config = config;
     this.logger = require('../../utils/logger');
     this.name = 'cloudformation';
-    this.port = config?.ports?.cloudformation || config?.services?.cloudformation?.port || 4580;
+    this.port = config?.ports?.cloudformation || config?.services?.cloudformation?.port || 4582;
     this.store = null;
     this.simulator = null;
     this._server = null;

package/src/services/cloudformation/server.js

@@ -1,3 +1,4 @@
+const { setupServiceMiddleware } = require('../../middleware');
 'use strict';
 
 /**