@nitronjs/framework 0.2.3 → 0.2.4

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;

package/lib/Database/Migration/MigrationRunner.js

@@ -4,20 +4,11 @@ import { pathToFileURL, fileURLToPath } from 'url';
 import Checksum from './Checksum.js';
 import MigrationRepository from './MigrationRepository.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() {
@@ -45,7 +36,7 @@ class MigrationRunner {
             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);
 
@@ -56,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 };
@@ -71,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: [] };
         }
 
@@ -80,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: [] };
         }
 
@@ -93,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: [], 
@@ -110,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 = [];
 
@@ -125,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);
 
@@ -137,32 +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}`);
+            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.");
                     }
                 }
             }
@@ -174,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 };
         }
     }
@@ -243,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);
     }
 
@@ -280,7 +280,8 @@ class MigrationRunner {
                     batch: record.batch,
                     executedAt: record.executed_at
                 };
-            } else {
+            }
+            else {
                 return {
                     name: file,
                     status: 'Pending',
@@ -297,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);
     }
 
 }