@nitronjs/framework 0.2.2 → 0.2.4

package/lib/Console/Output.js

@@ -0,0 +1,143 @@
+/**
+ * Console output utilities for CLI commands.
+ * Provides consistent, professional styling for terminal messages.
+ */
+
+const C = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m"
+};
+
+const I = {
+    success: "✔",
+    error: "✖",
+    warn: "⚠",
+    info: "◆",
+    pending: "◇",
+    arrow: "→",
+    bullet: "•",
+    sparkle: "✨",
+    database: "🗃️",
+    seed: "🌱"
+};
+
+// Common patterns
+const LINE = `${C.gray}${"-".repeat(45)}${C.reset}`;
+const DOTS = `${C.gray}···${C.reset}`;
+const log = console.log.bind(console);
+
+// Helper: prints section header
+const header = (icon, color, title, subtitle = "") => {
+    log(`  ${color}${icon}${C.reset}  ${C.bold}${title}${C.reset}${subtitle ? ` ${C.gray}${subtitle}${C.reset}` : ""}`);
+    log(`  ${LINE}`);
+};
+
+// Helper: prints section footer with success
+const footer = (message) => {
+    log(`  ${LINE}`);
+    log(`  ${C.green}${I.sparkle}${C.reset}  ${C.green}${C.bold}${message}${C.reset}`);
+    log();
+};
+
+// Helper: prints step row
+const step = (icon, color, action, target, suffix = "") => {
+    log(`  ${color}${icon}${C.reset} ${action}  ${DOTS}  ${target}${suffix}`);
+};
+
+// Basic messages
+const success = (msg) => log(`${C.green}${I.success}${C.reset} ${msg}`);
+const error = (msg) => log(`${C.red}${I.error}${C.reset} ${msg}`);
+const warn = (msg) => log(`${C.yellow}${I.warn}${C.reset} ${msg}`);
+const info = (msg) => log(`${C.blue}${I.info}${C.reset} ${msg}`);
+const dim = (msg) => log(`${C.dim}${msg}${C.reset}`);
+const newline = () => log();
+const errorDetail = (msg) => log(`  ${C.dim}${msg}${C.reset}`);
+
+// Task steps
+const done = (action, target) => step(I.success, C.green, action, `${C.white}${target}${C.reset}`);
+const pending = (action, target) => step(I.pending, C.gray, `${C.dim}${action}${C.reset}`, `${C.gray}${target}${C.reset}`);
+
+// Migration
+const migrationHeader = (batch) => header(I.database, C.magenta, "Running Migrations", `(batch ${batch})`);
+const migrationSuccess = () => footer("All migrations completed successfully");
+
+const frameworkMigration = (action, file) => {
+    const tag = `${C.magenta}[framework]${C.reset}`;
+    if (action === 'pending') {
+        step(I.pending, C.gray, `${C.dim}Migrating${C.reset}`, `${tag} ${C.gray}${file}${C.reset}`);
+    } else {
+        step(I.success, C.green, "Migrated ", `${tag} ${C.white}${file}${C.reset}`);
+    }
+};
+
+// Seeder
+const seederHeader = () => header(I.seed, C.cyan, "Running Seeders");
+const seederSuccess = () => footer("All seeders completed successfully");
+
+// Drop tables
+const dropTablesHeader = () => header(I.warn, C.yellow, "Dropping Tables");
+const droppingTable = (name) => step(I.pending, C.yellow, `${C.dim}Dropping${C.reset}`, `${C.yellow}${name}${C.reset}`);
+const dropTablesSuccess = (count) => {
+    log(`  ${LINE}`);
+    log(`  ${C.green}${I.success}${C.reset}  ${C.dim}Dropped ${count} table(s)${C.reset}`);
+    log();
+    log();
+};
+
+// Rollback
+const rollbackHeader = (count) => header(I.arrow, C.yellow, "Rolling Back", `(${count} migration${count > 1 ? 's' : ''})`);
+const rollbackDone = (file, batch) => step(I.success, C.yellow, "Rolled back", `${C.white}${file}${C.reset}`, ` ${C.gray}(batch ${batch})${C.reset}`);
+const rollbackSuccess = () => footer("Rollback completed successfully");
+
+// Status
+const statusHeader = () => header(I.info, C.blue, "Migration Status");
+const statusRow = (status, name, batch) => {
+    if (status === 'Ran') {
+        step(I.success, C.green, `${C.green}Ran${C.reset}    `, `${C.white}${name}${C.reset}`, ` ${C.gray}(batch ${batch})${C.reset}`);
+    }
+    else {
+        step(I.pending, C.yellow, `${C.yellow}Pending${C.reset}`, `${C.gray}${name}${C.reset}`);
+    }
+};
+const statusFooter = (total, ran, pend) => {
+    log(`  ${LINE}`);
+    log(`  ${C.dim}Total: ${total}  |  Ran: ${ran}  |  Pending: ${pend}${C.reset}`);
+    log();
+};
+
+export default {
+    COLORS: C,
+    ICONS: I,
+    success,
+    error,
+    warn,
+    info,
+    dim,
+    newline,
+    errorDetail,
+    done,
+    pending,
+    migrationHeader,
+    migrationSuccess,
+    frameworkMigration,
+    seederHeader,
+    seederSuccess,
+    dropTablesHeader,
+    droppingTable,
+    dropTablesSuccess,
+    rollbackHeader,
+    rollbackDone,
+    rollbackSuccess,
+    statusHeader,
+    statusRow,
+    statusFooter
+};

package/lib/Core/Config.js

@@ -21,7 +21,8 @@ class Config {
         for (const name of configFiles) {
             try {
                 this.#configs[name] = (await import(Paths.configUrl(name))).default;
-            } catch (err) {
+            }
+            catch (err) {
                 // Config file might not exist, that's ok
                 this.#configs[name] = {};
             }

package/lib/Core/Paths.js

@@ -4,6 +4,14 @@ import { pathToFileURL } from "url";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
+/**
+ * Path manager providing consistent access to framework and project directories.
+ * All paths are resolved relative to the project root (process.cwd()).
+ * 
+ * @example
+ * Paths.controllers  // /project/app/Controllers
+ * Paths.views        // /project/resources/views
+ */
 class Paths {
     static #framework = path.resolve(__dirname, "../..");
     static #project = process.cwd();
@@ -92,14 +100,6 @@ class Paths {
         return path.join(this.#project, "database/seeders");
     }
 
-    static get seedersProd() {
-        return path.join(this.#project, "database/seeders/prod");
-    }
-
-    static get seedersDev() {
-        return path.join(this.#project, "database/seeders/dev");
-    }
-
     static get storage() {
         return path.join(this.#project, "storage");
     }

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;