@nitronjs/framework 0.2.3 → 0.2.5

package/lib/Database/DB.js

@@ -1,84 +1,174 @@
-import DatabaseManager from "./Manager.js";
+import MySQLDriver from "./Drivers/MySQLDriver.js";
 import { query as createQueryBuilder, RawExpression } from "./QueryBuilder.js";
+import Config from "../Core/Config.js";
 
+/**
+ * Database manager providing query builder access, raw queries, and transactions.
+ * Supports multiple database drivers (currently MySQL).
+ * 
+ * @example
+ * const users = await DB.table("users").where("active", 1).get();
+ * await DB.transaction(async (conn) => { ... });
+ */
 class DB {
-    static manager() {
-        return DatabaseManager.getInstance();
+    static #driver = null;
+    static #config = null;
+    static #credentials = null;
+
+    /**
+     * Initializes database connection with configured driver.
+     * @returns {Promise<void>}
+     * @throws {Error} If health check fails
+     */
+    static async setup() {
+        this.#config = Config.all("database");
+
+        const envDriver = (process.env.DATABASE_DRIVER || "mysql").toLowerCase();
+
+        if (envDriver === "none") {
+            return;
+        }
+
+        this.#driver = this.#createDriver(envDriver);
+
+        const isHealthy = await this.#driver.healthCheck();
+
+        if (!isHealthy) {
+            throw new Error("Database connection health check failed. Check your .env credentials and ensure MySQL is running.");
+        }
     }
 
-    static connection(name = null) {
-        if (!this.#isEnabled()) return null;
-        return this.manager().connection(name);
+    /**
+     * Closes database connection and releases resources.
+     * @returns {Promise<void>}
+     */
+    static async close() {
+        if (this.#driver) {
+            await this.#driver.close();
+            this.#driver = null;
+        }
     }
 
-    static async query(sql, bindings = []) {
-        if (!this.#isEnabled()) return null;
-        return await this.manager().query(sql, bindings);
+    /**
+     * Creates a query builder for the specified table.
+     * @param {string} table - Table name
+     * @param {Function|null} modelClass - Optional model class for result mapping
+     * @returns {Object} Query builder instance
+     * @throws {Error} If database is disabled
+     */
+    static table(table, modelClass = null) {
+        if (!this.#driver) {
+            throw new Error("Database is disabled (DATABASE_DRIVER=none)");
+        }
+
+        return createQueryBuilder(table, this.#driver, modelClass);
     }
 
+    /**
+     * Creates a raw SQL expression for use in queries.
+     * @param {string} expression - Raw SQL expression
+     * @returns {RawExpression} Raw expression wrapper
+     */
     static rawExpr(expression) {
         return new RawExpression(expression);
     }
 
+    /**
+     * Executes a raw SQL query.
+     * @param {string} sql - Raw SQL string
+     * @returns {Promise<Array>} Query result
+     * @throws {Error} If database is disabled
+     */
     static async rawQuery(sql) {
-        if (!this.#isEnabled()) return null;
-        return await this.connection().raw(sql);
-    }
+        if (!this.#driver) {
+            throw new Error("Database is disabled (DATABASE_DRIVER=none)");
+        }
 
-    static async transaction(callback) {
-        if (!this.#isEnabled()) return null;
-        return await this.connection().withTransaction(callback);
+        return await this.#driver.raw(sql);
     }
 
     /**
-     * Create a query builder for a table.
-     * Uses lazy connection loading - connection is fetched only when query is executed.
-     * @param {string} table - The table name
-     * @param {string|null} connectionName - Optional connection name
-     * @param {Function|null} modelClass - Optional model class for hydration
-     * @returns {QueryBuilder} A query builder instance
+     * Executes a callback within a database transaction.
+     * @param {Function} callback - Async function receiving connection
+     * @param {Object} options - Transaction options
+     * @param {number} options.timeout - Timeout in milliseconds (default: 30000)
+     * @returns {Promise<*>} Callback result
+     * @throws {Error} If transaction times out or fails
      */
-    static table(table, connectionName = null, modelClass = null) {
-        // Pass connection directly now (synchronous)
-        const connection = this.connection(connectionName);
-        return createQueryBuilder(table, connection, modelClass);
-    }
-
-    static async setup() {
-        if (!this.#isEnabled()) return;
+    static async transaction(callback, options = {}) {
+        if (!this.#driver) {
+            throw new Error("Database is disabled (DATABASE_DRIVER=none)");
+        }
 
-        const manager = this.manager();
-        const defaultConnection = manager.getDefaultConnection();
+        const timeout = options.timeout || 30000;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
 
         try {
-            const connection = manager.connection(defaultConnection);
-            const isHealthy = await connection.healthCheck();
+            const result = await this.#driver.withTransaction(callback, { signal: controller.signal });
+            clearTimeout(timeoutId);
 
-            if (!isHealthy) {
-                throw new Error(`Database connection '${defaultConnection}' health check failed`);
-            }
+            return result;
         }
-        catch (error) {
-            console.error('[Database] Setup failed:', error.message);
-            console.error('[Database] Check your .env credentials and ensure MySQL is running');
-            throw error;
+        catch (err) {
+            clearTimeout(timeoutId);
+
+            if (controller.signal.aborted) {
+                throw new Error(
+                    `Transaction timeout after ${timeout}ms. ` +
+                    "Consider: 1) Adding await to all async operations, 2) Increasing timeout, 3) Optimizing queries."
+                );
+            }
+
+            throw err;
         }
     }
 
-    static async close() {
-        if (!this.#isEnabled()) return;
+    /**
+     * Reconfigures database with new credentials.
+     * Used by installer to test and save database settings.
+     * @param {Object} credentials - Database credentials
+     * @param {string} credentials.host - Database host
+     * @param {number} credentials.port - Database port
+     * @param {string} credentials.database - Database name
+     * @param {string} credentials.username - Database username
+     * @param {string} credentials.password - Database password
+     * @returns {Promise<void>}
+     */
+    static async reconfigure(credentials) {
+        await this.close();
 
-        try {
-            await this.manager().closeAll();
-        }
-        catch (error) {
-            console.error('[Database] Error during shutdown:', error.message);
-        }
+        this.#credentials = {
+            host: credentials.host,
+            port: String(credentials.port),
+            database: credentials.database,
+            username: credentials.username,
+            password: credentials.password || ""
+        };
+
+        this.#driver = this.#createDriver("mysql");
     }
 
-    static #isEnabled() {
-        return !!DatabaseManager.getInstance().getDefaultConnection();
+    /** @private */
+    static #createDriver(driverName) {
+        const connections = this.#config?.connections || {};
+        const config = connections[driverName];
+
+        if (!config) {
+            throw new Error(`Database connection '${driverName}' is not configured`);
+        }
+
+        switch (config.driver) {
+            case "mysql":
+                return new MySQLDriver(config, this.#credentials);
+            case "postgres":
+                throw new Error("Postgres driver not yet implemented");
+            case "mongodb":
+                throw new Error("MongoDB driver not yet implemented");
+            default:
+                throw new Error(`Unknown database driver: ${config.driver}`);
+        }
     }
 }
 
-export default DB;
+export default DB;

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;