@nitronjs/framework 0.2.2 → 0.2.4

package/lib/Database/Drivers/MySQLDriver.js

@@ -1,33 +1,37 @@
-import mysql from 'mysql2/promise';
-import Environment from '../../Core/Environment.js';
+import mysql from "mysql2/promise";
+import Environment from "../../Core/Environment.js";
 
+/**
+ * MySQL database driver using connection pooling.
+ * Handles query execution, transactions, and error management.
+ */
 class MySQLDriver {
     #pool = null;
     #config = null;
     #credentials = null;
 
+    /**
+     * Creates a new MySQL driver instance with connection pool.
+     * @param {Object} config - Database configuration from config/database.js
+     * @param {Object|null} credentials - Optional credential override for reconfiguration
+     */
     constructor(config, credentials = null) {
         this.#config = config;
         this.#credentials = credentials;
-        this.#createPool();
-    }
 
-    #createPool() {
         const creds = this.#credentials;
 
         this.#pool = mysql.createPool({
-            host: creds?.host ?? process.env.DATABASE_HOST ?? '127.0.0.1',
-            port: parseInt(creds?.port ?? process.env.DATABASE_PORT ?? '3306'),
-            user: creds?.username ?? process.env.DATABASE_USERNAME ?? 'root',
-            password: creds?.password ?? process.env.DATABASE_PASSWORD ?? '',
-            database: creds?.database ?? process.env.DATABASE_NAME ?? 'test',
-            charset: this.#config.charset || 'utf8mb4',
-
+            host: creds?.host ?? process.env.DATABASE_HOST ?? "127.0.0.1",
+            port: parseInt(creds?.port ?? process.env.DATABASE_PORT ?? "3306"),
+            user: creds?.username ?? process.env.DATABASE_USERNAME ?? "root",
+            password: creds?.password ?? process.env.DATABASE_PASSWORD ?? "",
+            database: creds?.database ?? process.env.DATABASE_NAME ?? "test",
+            charset: this.#config.charset || "utf8mb4",
             waitForConnections: true,
             connectionLimit: this.#config.pool?.max ?? 10,
             queueLimit: this.#config.pool?.queueLimit ?? 100,
             connectTimeout: 10000,
-
             enableKeepAlive: true,
             keepAliveInitialDelay: 10000,
             namedPlaceholders: true,
@@ -35,201 +39,142 @@ class MySQLDriver {
         });
     }
 
+    /**
+     * Executes a prepared SQL query with bindings.
+     * @param {string} sql - SQL query string
+     * @param {Array} bindings - Parameter bindings
+     * @returns {Promise<Array>} Query result [rows, fields]
+     * @throws {Error} On query failure
+     */
     async query(sql, bindings = []) {
-        const isProduction = Environment.isProd;
+        const connection = await this.#pool.getConnection();
 
         try {
-            const connection = await this.#pool.getConnection();
-
-            try {
-                await connection.query('SET SESSION MAX_EXECUTION_TIME = 60000');
-                const [rows, fields] = await connection.execute(sql, bindings);
+            await connection.query("SET SESSION MAX_EXECUTION_TIME = 60000");
 
-                return [rows, fields];
-            }
-            finally {
-                connection.release();
-            }
+            return await connection.execute(sql, bindings);
         }
-
         catch (error) {
-            if (isProduction) {
-                console.error('[MySQLDriver] Query failed', {
-                    code: error.code,
-                    errno: error.errno,
-                    sqlState: error.sqlState
-                });
-
-                const sanitized = new Error('Database query failed');
-                sanitized.code = error.code;
-                sanitized.driver = 'mysql';
-                throw sanitized;
-            }
-
-            error.sql = sql;
-            error.bindings = this.#maskSensitiveData(bindings);
-            error.driver = 'mysql';
-            throw error;
+            throw this.#handleError(error, sql, bindings);
+        }
+        finally {
+            connection.release();
         }
     }
 
+    /**
+     * Executes a raw SQL query without parameter binding.
+     * @param {string} sql - Raw SQL string
+     * @returns {Promise<Array>} Query result
+     */
     async raw(sql) {
-        const isProduction = Environment.isProd;
-        
         try {
-            const [rows, fields] = await this.#pool.query(sql);
-            return [rows, fields];
+            return await this.#pool.query(sql);
         }
-
         catch (error) {
-            if (isProduction) {
-                console.error('[MySQLDriver] Raw query failed', {
-                    code: error.code,
-                    errno: error.errno,
-                    sqlState: error.sqlState
-                });
-
-                const sanitized = new Error('Database query failed');
-                sanitized.code = error.code;
-                sanitized.driver = 'mysql';
-                throw sanitized;
-            }
-
-            error.sql = sql;
-            error.driver = 'mysql';
-            throw error;
+            throw this.#handleError(error, sql);
         }
     }
 
-    #maskSensitiveData(bindings) {
-        if (Environment.isDev) {
-            return bindings; // Show all in development
-        }
-
-        return bindings.map((value, index) => {
-            if (typeof value !== 'string') {
-                return value;
-            }
-
-            const sensitivePatterns = /password|token|secret|key|auth|bearer|jwt|otp|pin|credential/i;
-            const valuePreview = value.substring(0, 30).toLowerCase();
-            const looksLikeBase64 = /^[A-Za-z0-9+/]+=*$/.test(value) && value.length > 16;
-
-            if (sensitivePatterns.test(valuePreview) || value.length > 20 || looksLikeBase64) {
-                return '***MASKED***';
-            }
-
-            return value;
-        });
-    }
-
-    async beginTransaction() {
+    /**
+     * Executes callback within a database transaction.
+     * Automatically commits on success or rolls back on failure.
+     * @param {Function} callback - Async function receiving connection
+     * @param {Object} options - Transaction options
+     * @param {AbortSignal} options.signal - Abort signal for timeout
+     * @returns {Promise<*>} Callback result
+     */
+    async withTransaction(callback, options = {}) {
         const connection = await this.#pool.getConnection();
-        await connection.query('SET SESSION MAX_EXECUTION_TIME = 60000');
 
+        await connection.query("SET SESSION MAX_EXECUTION_TIME = 60000");
         await connection.beginTransaction();
 
-        return connection;
-    }
-
-    async commit(connection) {
         try {
-            await connection.commit();
-        }
+            if (options.signal?.aborted) {
+                throw new Error("Transaction aborted");
+            }
 
-        finally {
-            connection.release();
-        }
-    }
+            const result = await callback(connection);
 
-    async rollback(connection) {
-        try {
-            await connection.rollback();
-        }
+            if (options.signal?.aborted) {
+                await connection.rollback();
+                connection.release();
 
-        catch (error) {
-        }
+                throw new Error("Transaction aborted");
+            }
 
-        finally {
+            await connection.commit();
             connection.release();
-        }
-    }
 
-    async transactionQuery(connection, sql, bindings = []) {
-        try {
-            const [rows, fields] = await connection.execute(sql, bindings);
-            return [rows, fields];
+            return result;
         }
-
         catch (error) {
-            const isProduction = Environment.isProd;
-
-            if (isProduction) {
-                console.error('[MySQLDriver] Transaction query failed', {
-                    code: error.code,
-                    errno: error.errno,
-                    sqlState: error.sqlState,
-                    inTransaction: true
-                });
-
-                const sanitized = new Error('Database query failed');
-                sanitized.code = error.code;
-                sanitized.driver = 'mysql';
-                sanitized.inTransaction = true;
-                throw sanitized;
+            try {
+                await connection.rollback();
             }
-
-            error.sql = sql;
-            error.bindings = this.#maskSensitiveData(bindings);
-            error.driver = 'mysql';
-            error.inTransaction = true;
-            throw error;
-        }
-    }
-
-    async withTransaction(callback, options = {}) {
-        const signal = options?.signal;
-        const connection = await this.beginTransaction();
-
-        try {
-            if (signal?.aborted) {
-                throw new Error('Transaction aborted');
+            catch {
+                // Ignore rollback errors
             }
-
-            const result = await callback(connection);
-            if (signal?.aborted) {
-                await this.rollback(connection);
-                throw new Error('Transaction aborted');
+            finally {
+                connection.release();
             }
 
-            await this.commit(connection);
-
-            return result;
-        }
-
-        catch (error) {
-            await this.rollback(connection);
             throw error;
         }
     }
 
+    /**
+     * Checks if database connection is healthy.
+     * @returns {Promise<boolean>} True if connection is alive
+     */
     async healthCheck() {
         try {
-            await this.#pool.query('SELECT 1');
+            await this.#pool.query("SELECT 1");
+
             return true;
         }
-
-        catch (error) {
+        catch {
             return false;
         }
     }
 
+    /**
+     * Closes connection pool and releases resources.
+     * @returns {Promise<void>}
+     */
     async close() {
         if (this.#pool) {
             await this.#pool.end();
             this.#pool = null;
         }
     }
+
+    /** @private */
+    #handleError(error, sql, bindings = null) {
+        if (Environment.isProd) {
+            console.error("[MySQLDriver] Query failed", {
+                code: error.code,
+                errno: error.errno,
+                sqlState: error.sqlState
+            });
+
+            const sanitized = new Error("Database query failed");
+            sanitized.code = error.code;
+            sanitized.driver = "mysql";
+
+            return sanitized;
+        }
+
+        error.sql = sql;
+        error.driver = "mysql";
+
+        if (bindings) {
+            error.bindings = bindings;
+        }
+
+        return error;
+    }
 }
 
 export default MySQLDriver;

package/lib/Database/Migration/Checksum.js

@@ -2,22 +2,17 @@ import { createHash } from 'crypto';
 import fs from 'fs';
 
 class Checksum {
-
     static fromFile(filePath) {
-        const content = fs.readFileSync(filePath, 'utf8');
-        return this.fromContent(content);
+        return this.fromContent(fs.readFileSync(filePath, 'utf8'));
     }
 
     static fromContent(content) {
-        const normalized = content.replace(/\r\n/g, '\n').trim();
-        return createHash('sha256').update(normalized, 'utf8').digest('hex');
+        return createHash('sha256').update(content.replace(/\r\n/g, '\n').trim(), 'utf8').digest('hex');
     }
 
     static verify(filePath, expectedChecksum) {
-        const actualChecksum = this.fromFile(filePath);
-        return actualChecksum === expectedChecksum;
+        return this.fromFile(filePath) === expectedChecksum;
     }
-
 }
 
 export default Checksum;

package/lib/Database/Migration/MigrationRepository.js

@@ -1,9 +1,12 @@
 import DB from "../DB.js";
 
 class MigrationRepository {
-
     static table = 'migrations';
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // Public Methods
+    // ─────────────────────────────────────────────────────────────────────────
+
     static async tableExists() {
         const [rows] = await DB.rawQuery(`SHOW TABLES LIKE '${this.table}'`);
         return rows.length > 0;
@@ -11,67 +14,46 @@ class MigrationRepository {
 
     static async getExecuted() {
         if (!await this.tableExists()) return [];
-        return await DB.table(this.table)
-            .orderBy("batch", "asc")
-            .orderBy("id", "asc")
-            .get();
+        return await DB.table(this.table).orderBy('batch', 'asc').orderBy('id', 'asc').get();
     }
 
     static async getExecutedNames() {
-        const migrations = await this.getExecuted();
-        return new Set(migrations.map(m => m.name));
+        return new Set((await this.getExecuted()).map(m => m.name));
     }
 
     static async getNextBatchNumber() {
-        if (!await this.tableExists()) return 1;
-        const result = await DB.table(this.table)
-            .select(DB.rawExpr("MAX(batch) as max_batch"))
-            .first();
-        return (result?.max_batch || 0) + 1;
+        return (await this.#getMaxBatch()) + 1;
     }
 
     static async getLastBatchNumber() {
-        if (!await this.tableExists()) return 0;
-        const result = await DB.table(this.table)
-            .select(DB.rawExpr("MAX(batch) as max_batch"))
-            .first();
-        return result?.max_batch || 0;
+        return await this.#getMaxBatch();
     }
 
     static async getByBatch(batch) {
-        return await DB.table(this.table)
-            .where("batch", batch)
-            .orderBy("id", "desc")
-            .get();
+        return await DB.table(this.table).where('batch', batch).orderBy('id', 'desc').get();
     }
 
     static async getLastBatches(steps = 1) {
         const lastBatch = await this.getLastBatchNumber();
         if (lastBatch === 0) return [];
 
-        const minBatch = Math.max(1, lastBatch - steps + 1);
         return await DB.table(this.table)
-            .where("batch", ">=", minBatch)
-            .orderBy("batch", "desc")
-            .orderBy("id", "desc")
+            .where('batch', '>=', Math.max(1, lastBatch - steps + 1))
+            .orderBy('batch', 'desc')
+            .orderBy('id', 'desc')
             .get();
     }
 
     static async log(name, batch, checksum) {
-        await DB.table(this.table).insert({
-            name,
-            batch,
-            checksum,
-            executed_at: new Date()
-        });
+        await DB.table(this.table).insert({ name, batch, checksum, executed_at: new Date() });
     }
 
     static async delete(name) {
-        await DB.table(this.table).where("name", name).delete();
+        await DB.table(this.table).where('name', name).delete();
     }
 
     static async find(name) {
-        return await DB.table(this.table).where("name", name).first();
+        return await DB.table(this.table).where('name', name).first();
     }
 
     static async exists(name) {
@@ -79,10 +61,18 @@ class MigrationRepository {
     }
 
     static async getChecksum(name) {
-        const migration = await this.find(name);
-        return migration?.checksum || null;
+        return (await this.find(name))?.checksum || null;
     }
 
+    // ─────────────────────────────────────────────────────────────────────────
+    // Private Methods
+    // ─────────────────────────────────────────────────────────────────────────
+
+    static async #getMaxBatch() {
+        if (!await this.tableExists()) return 0;
+        const result = await DB.table(this.table).select(DB.rawExpr('MAX(batch) as max_batch')).first();
+        return result?.max_batch || 0;
+    }
 }
 
 export default MigrationRepository;