@nitronjs/framework 0.2.2 → 0.2.4

package/lib/Database/Migration/MigrationRunner.js

@@ -3,22 +3,12 @@ import path from 'path';
 import { pathToFileURL, fileURLToPath } from 'url';
 import Checksum from './Checksum.js';
 import MigrationRepository from './MigrationRepository.js';
-import SeederRepository from '../Seeder/SeederRepository.js';
 import Paths from '../../Core/Paths.js';
+import Output from '../../Console/Output.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const COLORS = {
-    reset: '\x1b[0m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    cyan: '\x1b[36m',
-    dim: '\x1b[2m',
-    bold: '\x1b[1m'
-};
-
 class MigrationRunner {
 
     static get frameworkMigrationsDir() {
@@ -39,17 +29,14 @@ class MigrationRunner {
         const ran = [];
 
         for (const file of files) {
-            const isMigrationsTable = file.includes('migrations');
-            const tableExists = isMigrationsTable 
-                ? await MigrationRepository.tableExists()
-                : await SeederRepository.tableExists();
+            const tableExists = await MigrationRepository.tableExists();
 
             if (tableExists) continue;
 
             const filePath = path.join(frameworkDir, file);
             const fileUrl = pathToFileURL(filePath).href;
 
-            console.log(`${COLORS.dim}Migrating:${COLORS.reset} ${COLORS.cyan}[framework] ${file}${COLORS.reset}`);
+            Output.frameworkMigration('pending', file);
 
             const { default: migration } = await import(fileUrl);
 
@@ -60,7 +47,7 @@ class MigrationRunner {
             await migration.up();
             ran.push(file);
 
-            console.log(`${COLORS.green}✅ Migrated:${COLORS.reset}  ${COLORS.cyan}[framework] ${file}${COLORS.reset}\n`);
+            Output.frameworkMigration('done', file);
         }
 
         return { success: true, ran };
@@ -75,7 +62,7 @@ class MigrationRunner {
         const migrationsDir = Paths.migrations;
 
         if (!fs.existsSync(migrationsDir)) {
-            console.log(`${COLORS.yellow}⚠️  No migrations directory found${COLORS.reset}`);
+            Output.warn("No migrations directory found");
             return { success: true, ran: [] };
         }
 
@@ -84,7 +71,7 @@ class MigrationRunner {
             .sort();
 
         if (files.length === 0) {
-            console.log(`${COLORS.yellow}⚠️  No migration files found${COLORS.reset}`);
+            Output.warn("No migration files found");
             return { success: true, ran: [] };
         }
 
@@ -97,11 +84,11 @@ class MigrationRunner {
                 const storedChecksum = await MigrationRepository.getChecksum(file);
 
                 if (currentChecksum !== storedChecksum) {
-                    console.error(`${COLORS.red}❌ CHECKSUM MISMATCH: ${file}${COLORS.reset}`);
-                    console.error(`${COLORS.dim}   Stored:  ${storedChecksum}${COLORS.reset}`);
-                    console.error(`${COLORS.dim}   Current: ${currentChecksum}${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Migration files must NEVER be modified after execution.${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Create a NEW migration for any schema changes.${COLORS.reset}`);
+                    Output.error(`Checksum mismatch: ${file}`);
+                    Output.errorDetail(`Stored:  ${storedChecksum}`);
+                    Output.errorDetail(`Current: ${currentChecksum}`);
+                    Output.error("Migration files must NEVER be modified after execution.");
+                    Output.error("Create a NEW migration for any schema changes.");
                     return { 
                         success: false, 
                         ran: [], 
@@ -114,12 +101,13 @@ class MigrationRunner {
         const pending = files.filter(f => !executedNames.has(f));
 
         if (pending.length === 0) {
-            console.log(`${COLORS.green}✅ Nothing to migrate. All migrations are up to date.${COLORS.reset}`);
+            console.log(`  ${Output.COLORS.green}${Output.ICONS.success}${Output.COLORS.reset}  ${Output.COLORS.dim}Nothing to migrate. All migrations are up to date.${Output.COLORS.reset}`);
+            console.log();
             return { success: true, ran: [] };
         }
 
         const batch = await MigrationRepository.getNextBatchNumber();
-        console.log(`${COLORS.cyan}📦 Running migrations (batch ${batch})${COLORS.reset}\n`);
+        Output.migrationHeader(batch);
 
         const executedInBatch = [];
 
@@ -129,7 +117,7 @@ class MigrationRunner {
                 const fileUrl = pathToFileURL(filePath).href;
                 const checksum = Checksum.fromFile(filePath);
 
-                console.log(`${COLORS.dim}Migrating:${COLORS.reset} ${COLORS.cyan}${file}${COLORS.reset}`);
+                Output.pending("Migrating", file);
 
                 const { default: migration } = await import(fileUrl);
 
@@ -141,31 +129,37 @@ class MigrationRunner {
                 await MigrationRepository.log(file, batch, checksum);
                 executedInBatch.push({ file, migration });
 
-                console.log(`${COLORS.green}✅ Migrated:${COLORS.reset}  ${COLORS.cyan}${file}${COLORS.reset}\n`);
+                Output.done("Migrated", file);
             }
 
-            console.log(`${COLORS.green}${COLORS.bold}✅ All migrations completed successfully.${COLORS.reset}`);
+            Output.migrationSuccess();
             return { success: true, ran: executedInBatch.map(e => e.file) };
 
-        } catch (error) {
-            console.error(`\n${COLORS.red}❌ Migration failed: ${error.message}${COLORS.reset}`);
+        }
+        catch (error) {
+            Output.newline();
+            Output.error(`Migration failed: ${error.message}`);
 
             if (executedInBatch.length > 0) {
-                console.log(`\n${COLORS.yellow}⚠️  Rolling back ${executedInBatch.length} migration(s) from this batch...${COLORS.reset}\n`);
+                Output.newline();
+                Output.warn(`Rolling back ${executedInBatch.length} migration(s) from this batch...`);
+                Output.newline();
 
                 for (const { file, migration } of executedInBatch.reverse()) {
                     try {
-                        console.log(`${COLORS.dim}Rolling back:${COLORS.reset} ${COLORS.cyan}${file}${COLORS.reset}`);
+                        Output.pending("Rolling back", file);
 
                         if (typeof migration.down === 'function') {
                             await migration.down();
                         }
 
                         await MigrationRepository.delete(file);
-                        console.log(`${COLORS.yellow}↩️  Rolled back:${COLORS.reset} ${COLORS.cyan}${file}${COLORS.reset}\n`);
-                    } catch (rollbackError) {
-                        console.error(`${COLORS.red}❌ Rollback failed for ${file}: ${rollbackError.message}${COLORS.reset}`);
-                        console.error(`${COLORS.red}   Manual intervention may be required.${COLORS.reset}`);
+                        Output.rollback("Rolled back", file);
+                        Output.newline();
+                    }
+                    catch (rollbackError) {
+                        Output.error(`Rollback failed for ${file}: ${rollbackError.message}`);
+                        Output.error("Manual intervention may be required.");
                     }
                 }
             }
@@ -177,68 +171,70 @@ class MigrationRunner {
     static async rollback(steps = 1) {
         const tableExists = await MigrationRepository.tableExists();
         if (!tableExists) {
-            console.log(`${COLORS.yellow}⚠️  No migrations have been run yet.${COLORS.reset}`);
+            Output.warn("No migrations have been run yet.");
             return { success: true, rolledBack: [] };
         }
 
         const lastBatch = await MigrationRepository.getLastBatchNumber();
         if (lastBatch === 0) {
-            console.log(`${COLORS.yellow}⚠️  Nothing to rollback.${COLORS.reset}`);
+            Output.warn("Nothing to rollback.");
             return { success: true, rolledBack: [] };
         }
 
         const toRollback = await MigrationRepository.getLastBatches(steps);
 
         if (toRollback.length === 0) {
-            console.log(`${COLORS.yellow}⚠️  Nothing to rollback.${COLORS.reset}`);
+            Output.warn("Nothing to rollback.");
             return { success: true, rolledBack: [] };
         }
 
         const migrationsDir = Paths.migrations;
         const rolledBack = [];
 
-        console.log(`${COLORS.yellow}⚠️  Rolling back ${toRollback.length} migration(s)...${COLORS.reset}\n`);
+        Output.rollbackHeader(toRollback.length);
 
         try {
             for (const record of toRollback) {
                 const filePath = path.join(migrationsDir, record.name);
 
                 if (!fs.existsSync(filePath)) {
-                    console.error(`${COLORS.red}❌ Migration file not found: ${record.name}${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Cannot rollback without the migration file.${COLORS.reset}`);
+                    Output.error(`Migration file not found: ${record.name}`);
+                    Output.errorDetail("Cannot rollback without the migration file.");
                     throw new Error(`Migration file not found: ${record.name}`);
                 }
 
                 const currentChecksum = Checksum.fromFile(filePath);
                 if (currentChecksum !== record.checksum) {
-                    console.error(`${COLORS.red}❌ CHECKSUM MISMATCH: ${record.name}${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Migration file was modified after execution.${COLORS.reset}`);
-                    console.error(`${COLORS.red}   Rollback cannot proceed safely.${COLORS.reset}`);
+                    Output.error(`Checksum mismatch: ${record.name}`);
+                    Output.errorDetail("Migration file was modified after execution.");
+                    Output.errorDetail("Rollback cannot proceed safely.");
                     throw new Error(`Checksum mismatch for migration: ${record.name}`);
                 }
 
                 const fileUrl = pathToFileURL(filePath).href;
                 const { default: migration } = await import(fileUrl);
 
-                console.log(`${COLORS.dim}Rolling back:${COLORS.reset} ${COLORS.cyan}${record.name}${COLORS.reset} ${COLORS.dim}(batch ${record.batch})${COLORS.reset}`);
+                Output.pending("Rolling back", `${record.name} (batch ${record.batch})`);
 
                 if (typeof migration.down === 'function') {
                     await migration.down();
                 } else {
-                    console.warn(`${COLORS.yellow}   ⚠️  No down() method, skipping schema rollback${COLORS.reset}`);
+                    Output.warn("No down() method, skipping schema rollback");
                 }
 
                 await MigrationRepository.delete(record.name);
                 rolledBack.push(record.name);
 
-                console.log(`${COLORS.yellow}↩️  Rolled back:${COLORS.reset} ${COLORS.cyan}${record.name}${COLORS.reset}\n`);
+                Output.rollbackDone(record.name, record.batch);
             }
 
-            console.log(`${COLORS.green}${COLORS.bold}✅ Rollback completed successfully.${COLORS.reset}`);
+            Output.rollbackSuccess();
             return { success: true, rolledBack };
 
-        } catch (error) {
-            console.error(`\n${COLORS.red}❌ Rollback failed: ${error.message}${COLORS.reset}`);
+        }
+        catch (error) {
+            Output.newline();
+            Output.error(`Rollback failed: ${error.message}`);
             return { success: false, rolledBack, error };
         }
     }
@@ -246,17 +242,18 @@ class MigrationRunner {
     static async reset() {
         const tableExists = await MigrationRepository.tableExists();
         if (!tableExists) {
-            console.log(`${COLORS.yellow}⚠️  No migrations have been run yet.${COLORS.reset}`);
+            Output.warn("No migrations have been run yet.");
             return { success: true, rolledBack: [] };
         }
 
         const lastBatch = await MigrationRepository.getLastBatchNumber();
         if (lastBatch === 0) {
-            console.log(`${COLORS.yellow}⚠️  Nothing to reset.${COLORS.reset}`);
+            Output.warn("Nothing to reset.");
             return { success: true, rolledBack: [] };
         }
 
-        console.log(`${COLORS.yellow}⚠️  Resetting all migrations...${COLORS.reset}\n`);
+        Output.warn("Resetting all migrations...");
+        Output.newline();
         return await this.rollback(lastBatch);
     }
 
@@ -283,7 +280,8 @@ class MigrationRunner {
                     batch: record.batch,
                     executedAt: record.executed_at
                 };
-            } else {
+            }
+            else {
                 return {
                     name: file,
                     status: 'Pending',
@@ -300,26 +298,20 @@ class MigrationRunner {
         const status = await this.status();
 
         if (status.length === 0) {
-            console.log(`${COLORS.yellow}⚠️  No migrations found.${COLORS.reset}`);
+            console.log(`  ${Output.COLORS.green}${Output.ICONS.success}${Output.COLORS.reset}  ${Output.COLORS.dim}No migrations found${Output.COLORS.reset}`);
+            Output.newline();
             return;
         }
 
-        console.log(`\n${COLORS.bold}Migration Status${COLORS.reset}\n`);
-        console.log(`${COLORS.dim}${'─'.repeat(80)}${COLORS.reset}`);
+        Output.statusHeader();
 
         for (const migration of status) {
-            const statusColor = migration.status === 'Ran' ? COLORS.green : COLORS.yellow;
-            const statusIcon = migration.status === 'Ran' ? '✅' : '⏳';
-            const batchInfo = migration.batch ? ` ${COLORS.dim}(batch ${migration.batch})${COLORS.reset}` : '';
-
-            console.log(`${statusIcon} ${statusColor}${migration.status.padEnd(7)}${COLORS.reset} ${migration.name}${batchInfo}`);
+            Output.statusRow(migration.status, migration.name, migration.batch);
         }
 
-        console.log(`${COLORS.dim}${'─'.repeat(80)}${COLORS.reset}\n`);
-
         const ran = status.filter(m => m.status === 'Ran').length;
         const pending = status.filter(m => m.status === 'Pending').length;
-        console.log(`${COLORS.dim}Total: ${status.length} | Ran: ${ran} | Pending: ${pending}${COLORS.reset}\n`);
+        Output.statusFooter(status.length, ran, pending);
     }
 
 }

package/lib/Database/Model.js

@@ -1,29 +1,60 @@
 import DB from './DB.js';
 
+/**
+ * Base model class for database entities with Active Record pattern.
+ * Provides CRUD operations and query builder integration.
+ * 
+ * @example
+ * class User extends Model {
+ *     static table = "users";
+ * }
+ * 
+ * const user = await User.find(1);
+ * user.name = "John";
+ * await user.save();
+ */
 class Model {
+    /** @type {string|null} Database table name - must be defined in subclass */
     static table = null;
 
+    /**
+     * Creates a new model instance with attribute proxy support.
+     * @param {Object} attrs - Initial attributes
+     */
     constructor(attrs = {}) {
         Object.defineProperty(this, '_attributes', { value: {}, writable: true });
         Object.defineProperty(this, '_original', { value: {}, writable: true });
         Object.defineProperty(this, '_exists', { value: false, writable: true });
-        
+
         Object.assign(this._attributes, attrs);
         this._original = { ...this._attributes };
-        
+
         return new Proxy(this, {
-            get(target, prop) {
-                if (prop.startsWith('_') || typeof target[prop] === 'function' || prop === 'constructor') {
+            get: (target, prop) => {
+                if (typeof prop === 'symbol' || prop === 'constructor') {
+                    return target[prop];
+                }
+
+                if (prop.startsWith('_')) {
                     return target[prop];
                 }
+
+                if (prop in target && typeof target[prop] === 'function') {
+                    return target[prop].bind(target);
+                }
+
                 return target._attributes[prop];
             },
-            set(target, prop, value) {
-                if (prop.startsWith('_')) {
+            set: (target, prop, value) => {
+                if (typeof prop === 'symbol' || prop.startsWith('_')) {
                     target[prop] = value;
+
                     return true;
                 }
-                if (prop in target) return false;
+
+                if (prop in target) {
+                    return false;
+                }
 
                 target._attributes[prop] = value;
 
@@ -32,129 +63,188 @@ class Model {
         });
     }
 
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Static Query Methods
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Get all records from the table.
+     * @returns {Promise<Model[]>}
+     */
     static async get() {
-        if (!this.table) {
-            throw new Error(`Model ${this.name} must define a static 'table' property`);
-        }
+        ensureTable(this);
 
         const rows = await DB.table(this.table).get();
 
-        return rows.map(row => {
-            const instance = new this();
-            
-            for (const [key, value] of Object.entries(row)) {
-                if (value instanceof Date) {
-                    instance._attributes[key] = value.toISOString().slice(0, 19).replace('T', ' ');
-                } else {
-                    instance._attributes[key] = value;
-                }
-            }
-            
-            instance._exists = true;
-            instance._original = { ...instance._attributes };
-            
-            return instance;
-        });
+        return rows.map(row => hydrate(this, row));
     }
 
+    /**
+     * Find a record by ID.
+     * @param {number|string} id - Record ID
+     * @returns {Promise<Model|null>}
+     */
     static async find(id) {
-        if (!this.table) {
-            throw new Error(`Model ${this.name} must define a static 'table' property`);
-        }
+        ensureTable(this);
 
-        const row = await DB.table(this.table).where("id", id).first();
+        const row = await DB.table(this.table).where('id', id).first();
 
-        if (!row) return null;
+        return row ? hydrate(this, row) : null;
+    }
 
-        const instance = new this();
-        
-        for (const [key, value] of Object.entries(row)) {
-            if (value instanceof Date) {
-                instance._attributes[key] = value.toISOString().slice(0, 19).replace('T', ' ');
-            } else {
-                instance._attributes[key] = value;
-            }
-        }
-        
-        instance._exists = true;
-        instance._original = { ...instance._attributes };
-        
-        return instance;
+    /**
+     * Get the first record from the table.
+     * @returns {Promise<Model|null>}
+     */
+    static async first() {
+        ensureTable(this);
+
+        const row = await DB.table(this.table).first();
+
+        return row ? hydrate(this, row) : null;
     }
 
+    /**
+     * Add a WHERE clause to the query.
+     * @param {string|Object} column - Column name or conditions object
+     * @param {string} [operator] - Comparison operator or value (if 2 args)
+     * @param {*} [value] - Value to compare
+     * @returns {import('./QueryBuilder.js').default}
+     */
     static where(column, operator, value) {
-        if (!this.table) {
-            throw new Error(`Model ${this.name} must define a static 'table' property`);
+        ensureTable(this);
+
+        if (arguments.length === 2) {
+            return DB.table(this.table, null, this).where(column, operator);
         }
 
         return DB.table(this.table, null, this).where(column, operator, value);
     }
 
+    /**
+     * Select specific columns.
+     * @param {...string} columns - Column names
+     * @returns {import('./QueryBuilder.js').default}
+     */
     static select(...columns) {
-        if (!this.table) {
-            throw new Error(`Model ${this.name} must define a static 'table' property`);
-        }
+        ensureTable(this);
 
         return DB.table(this.table, null, this).select(...columns);
     }
 
-    static async first() {
-        if (!this.table) {
-            throw new Error(`Model ${this.name} must define a static 'table' property`);
-        }
+    /**
+     * Order results by column.
+     * @param {string} column - Column name
+     * @param {'ASC'|'DESC'} [direction='ASC'] - Sort direction
+     * @returns {import('./QueryBuilder.js').default}
+     */
+    static orderBy(column, direction = 'ASC') {
+        ensureTable(this);
 
-        return await DB.table(this.table, null, this).limit(1).first();
+        return DB.table(this.table, null, this).orderBy(column, direction);
     }
 
+    /**
+     * Limit the number of results.
+     * @param {number} value - Maximum records to return
+     * @returns {import('./QueryBuilder.js').default}
+     */
+    static limit(value) {
+        ensureTable(this);
+
+        return DB.table(this.table, null, this).limit(value);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Instance Methods
+    // ─────────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Save the model (insert or update).
+     * @returns {Promise<Model>}
+     */
     async save() {
-        const constructor = this.constructor;
+        const table = this.constructor.table;
         const data = {};
 
         for (const [key, value] of Object.entries(this._attributes)) {
-            if (value !== undefined && (key !== "id" || !this._exists)) {
+            if (value !== undefined && (key !== 'id' || !this._exists)) {
                 data[key] = value;
             }
         }
 
         if (this._exists) {
-            const primaryKeyValue = this._attributes["id"];
-            await DB.table(constructor.table)
-                .where("id", primaryKeyValue)
-                .update(data);
-            
-            Object.assign(this._attributes, data);
-            this._original = { ...this._attributes };
+            await DB.table(table).where('id', this._attributes.id).update(data);
         }
         else {
-            const id = await DB.table(constructor.table).insert(data);
-            this._attributes["id"] = id;
-            
-            this._original = { ...this._attributes };
+            const id = await DB.table(table).insert(data);
+            this._attributes.id = id;
             this._exists = true;
         }
 
+        this._original = { ...this._attributes };
+
         return this;
     }
 
+    /**
+     * Delete the model from database.
+     * @returns {Promise<boolean>}
+     * @throws {Error} If model doesn't exist in database
+     */
     async delete() {
-        const constructor = this.constructor;
-        const primaryKeyValue = this._attributes["id"];
-        
         if (!this._exists) {
             throw new Error('Cannot delete a model that does not exist');
         }
 
-        await DB.table(constructor.table)
-            .where("id", primaryKeyValue)
-            .delete();
-
+        await DB.table(this.constructor.table).where('id', this._attributes.id).delete();
         this._exists = false;
+
         return true;
     }
 
+    /**
+     * Convert model attributes to plain object.
+     * @returns {Object}
+     */
     toObject() {
         return { ...this._attributes };
     }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Private Helper Functions (module-scoped to avoid ES6 static inheritance issues)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Validates that table property is defined on the model class.
+ * @param {typeof Model} modelClass
+ */
+function ensureTable(modelClass) {
+    if (!modelClass.table) {
+        throw new Error(`Model ${modelClass.name} must define a static 'table' property`);
+    }
+}
+
+/**
+ * Creates a model instance from a database row.
+ * @param {typeof Model} modelClass
+ * @param {Object} row
+ * @returns {Model}
+ */
+function hydrate(modelClass, row) {
+    const instance = new modelClass();
+
+    for (const [key, value] of Object.entries(row)) {
+        instance._attributes[key] = value instanceof Date
+            ? value.toISOString().slice(0, 19).replace('T', ' ')
+            : value;
+    }
+
+    instance._exists = true;
+    instance._original = { ...instance._attributes };
+
+    return instance;
+}
+
 export default Model;