@nitronjs/framework 0.1.22 → 0.1.23

package/lib/Database/Migration/MigrationRepository.js

@@ -0,0 +1,92 @@
+import DB from "../DB.js";
+
+class MigrationRepository {
+
+    static table = 'migrations';
+
+    static async tableExists() {
+        try {
+            await DB.table(this.table).limit(1).get();
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    static async getExecuted() {
+        if (!await this.tableExists()) return [];
+        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));
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    static async getByBatch(batch) {
+        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")
+            .get();
+    }
+
+    static async log(name, batch, checksum) {
+        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();
+    }
+
+    static async find(name) {
+        return await DB.table(this.table).where("name", name).first();
+    }
+
+    static async exists(name) {
+        return (await this.find(name)) !== null;
+    }
+
+    static async getChecksum(name) {
+        const migration = await this.find(name);
+        return migration?.checksum || null;
+    }
+
+}
+
+export default MigrationRepository;

package/lib/Database/Migration/MigrationRunner.js

@@ -0,0 +1,327 @@
+import fs from 'fs';
+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';
+
+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() {
+        return path.join(__dirname, 'migrations');
+    }
+
+    static async runFrameworkMigrations() {
+        const frameworkDir = this.frameworkMigrationsDir;
+
+        if (!fs.existsSync(frameworkDir)) {
+            return { success: true, ran: [] };
+        }
+
+        const files = fs.readdirSync(frameworkDir)
+            .filter(f => f.endsWith('.js'))
+            .sort();
+
+        const ran = [];
+
+        for (const file of files) {
+            const isMigrationsTable = file.includes('migrations');
+            const tableExists = isMigrationsTable 
+                ? await MigrationRepository.tableExists()
+                : await SeederRepository.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}`);
+
+            const { default: migration } = await import(fileUrl);
+
+            if (typeof migration.up !== 'function') {
+                throw new Error(`Framework migration ${file} does not have an up() method`);
+            }
+
+            await migration.up();
+            ran.push(file);
+
+            console.log(`${COLORS.green}✅ Migrated:${COLORS.reset}  ${COLORS.cyan}[framework] ${file}${COLORS.reset}\n`);
+        }
+
+        return { success: true, ran };
+    }
+
+    static async run() {
+        const frameworkResult = await this.runFrameworkMigrations();
+        if (!frameworkResult.success) {
+            return frameworkResult;
+        }
+
+        const migrationsDir = Paths.migrations;
+
+        if (!fs.existsSync(migrationsDir)) {
+            console.log(`${COLORS.yellow}⚠️  No migrations directory found${COLORS.reset}`);
+            return { success: true, ran: [] };
+        }
+
+        const files = fs.readdirSync(migrationsDir)
+            .filter(f => f.endsWith('.js'))
+            .sort();
+
+        if (files.length === 0) {
+            console.log(`${COLORS.yellow}⚠️  No migration files found${COLORS.reset}`);
+            return { success: true, ran: [] };
+        }
+
+        const executedNames = await MigrationRepository.getExecutedNames();
+
+        for (const file of files) {
+            if (executedNames.has(file)) {
+                const filePath = path.join(migrationsDir, file);
+                const currentChecksum = Checksum.fromFile(filePath);
+                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}`);
+                    return { 
+                        success: false, 
+                        ran: [], 
+                        error: new Error(`Checksum mismatch for migration: ${file}`) 
+                    };
+                }
+            }
+        }
+
+        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}`);
+            return { success: true, ran: [] };
+        }
+
+        const batch = await MigrationRepository.getNextBatchNumber();
+        console.log(`${COLORS.cyan}📦 Running migrations (batch ${batch})${COLORS.reset}\n`);
+
+        const executedInBatch = [];
+
+        try {
+            for (const file of pending) {
+                const filePath = path.join(migrationsDir, file);
+                const fileUrl = pathToFileURL(filePath).href;
+                const checksum = Checksum.fromFile(filePath);
+
+                console.log(`${COLORS.dim}Migrating:${COLORS.reset} ${COLORS.cyan}${file}${COLORS.reset}`);
+
+                const { default: migration } = await import(fileUrl);
+
+                if (typeof migration.up !== 'function') {
+                    throw new Error(`Migration ${file} does not have an up() method`);
+                }
+
+                await migration.up();
+                await MigrationRepository.log(file, batch, checksum);
+                executedInBatch.push({ file, migration });
+
+                console.log(`${COLORS.green}✅ Migrated:${COLORS.reset}  ${COLORS.cyan}${file}${COLORS.reset}\n`);
+            }
+
+            console.log(`${COLORS.green}${COLORS.bold}✅ All migrations completed successfully.${COLORS.reset}`);
+            return { success: true, ran: executedInBatch.map(e => e.file) };
+
+        } catch (error) {
+            console.error(`\n${COLORS.red}❌ Migration failed: ${error.message}${COLORS.reset}`);
+
+            if (executedInBatch.length > 0) {
+                console.log(`\n${COLORS.yellow}⚠️  Rolling back ${executedInBatch.length} migration(s) from this batch...${COLORS.reset}\n`);
+
+                for (const { file, migration } of executedInBatch.reverse()) {
+                    try {
+                        console.log(`${COLORS.dim}Rolling back:${COLORS.reset} ${COLORS.cyan}${file}${COLORS.reset}`);
+
+                        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}`);
+                    }
+                }
+            }
+
+            return { success: false, ran: [], error };
+        }
+    }
+
+    static async rollback(steps = 1) {
+        const tableExists = await MigrationRepository.tableExists();
+        if (!tableExists) {
+            console.log(`${COLORS.yellow}⚠️  No migrations have been run yet.${COLORS.reset}`);
+            return { success: true, rolledBack: [] };
+        }
+
+        const lastBatch = await MigrationRepository.getLastBatchNumber();
+        if (lastBatch === 0) {
+            console.log(`${COLORS.yellow}⚠️  Nothing to rollback.${COLORS.reset}`);
+            return { success: true, rolledBack: [] };
+        }
+
+        const toRollback = await MigrationRepository.getLastBatches(steps);
+
+        if (toRollback.length === 0) {
+            console.log(`${COLORS.yellow}⚠️  Nothing to rollback.${COLORS.reset}`);
+            return { success: true, rolledBack: [] };
+        }
+
+        const migrationsDir = Paths.migrations;
+        const rolledBack = [];
+
+        console.log(`${COLORS.yellow}⚠️  Rolling back ${toRollback.length} migration(s)...${COLORS.reset}\n`);
+
+        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}`);
+                    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}`);
+                    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}`);
+
+                if (typeof migration.down === 'function') {
+                    await migration.down();
+                } else {
+                    console.warn(`${COLORS.yellow}   ⚠️  No down() method, skipping schema rollback${COLORS.reset}`);
+                }
+
+                await MigrationRepository.delete(record.name);
+                rolledBack.push(record.name);
+
+                console.log(`${COLORS.yellow}↩️  Rolled back:${COLORS.reset} ${COLORS.cyan}${record.name}${COLORS.reset}\n`);
+            }
+
+            console.log(`${COLORS.green}${COLORS.bold}✅ Rollback completed successfully.${COLORS.reset}`);
+            return { success: true, rolledBack };
+
+        } catch (error) {
+            console.error(`\n${COLORS.red}❌ Rollback failed: ${error.message}${COLORS.reset}`);
+            return { success: false, rolledBack, error };
+        }
+    }
+
+    static async reset() {
+        const tableExists = await MigrationRepository.tableExists();
+        if (!tableExists) {
+            console.log(`${COLORS.yellow}⚠️  No migrations have been run yet.${COLORS.reset}`);
+            return { success: true, rolledBack: [] };
+        }
+
+        const lastBatch = await MigrationRepository.getLastBatchNumber();
+        if (lastBatch === 0) {
+            console.log(`${COLORS.yellow}⚠️  Nothing to reset.${COLORS.reset}`);
+            return { success: true, rolledBack: [] };
+        }
+
+        console.log(`${COLORS.yellow}⚠️  Resetting all migrations...${COLORS.reset}\n`);
+        return await this.rollback(lastBatch);
+    }
+
+    static async status() {
+        const migrationsDir = Paths.migrations;
+
+        if (!fs.existsSync(migrationsDir)) {
+            return [];
+        }
+
+        const files = fs.readdirSync(migrationsDir)
+            .filter(f => f.endsWith('.js'))
+            .sort();
+
+        const executed = await MigrationRepository.getExecuted();
+        const executedMap = new Map(executed.map(m => [m.name, m]));
+
+        const status = files.map(file => {
+            const record = executedMap.get(file);
+            if (record) {
+                return {
+                    name: file,
+                    status: 'Ran',
+                    batch: record.batch,
+                    executedAt: record.executed_at
+                };
+            } else {
+                return {
+                    name: file,
+                    status: 'Pending',
+                    batch: null,
+                    executedAt: null
+                };
+            }
+        });
+
+        return status;
+    }
+
+    static async printStatus() {
+        const status = await this.status();
+
+        if (status.length === 0) {
+            console.log(`${COLORS.yellow}⚠️  No migrations found.${COLORS.reset}`);
+            return;
+        }
+
+        console.log(`\n${COLORS.bold}Migration Status${COLORS.reset}\n`);
+        console.log(`${COLORS.dim}${'─'.repeat(80)}${COLORS.reset}`);
+
+        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}`);
+        }
+
+        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`);
+    }
+
+}
+
+export default MigrationRunner;

package/lib/Database/Migration/migrations/0000_00_00_00_00_create_migrations_table.js

@@ -0,0 +1,21 @@
+import Schema from "../../Schema/Manager.js";
+
+class CreateMigrationsTable {
+
+    static async up() {
+        await Schema.create("migrations", (table) => {
+            table.id();
+            table.string("name").unique();
+            table.integer("batch");
+            table.string("checksum", 64);
+            table.timestamp("executed_at");
+        });
+    }
+
+    static async down() {
+        await Schema.dropIfExists("migrations");
+    }
+
+}
+
+export default CreateMigrationsTable;

package/lib/Database/Migration/migrations/0000_00_00_00_01_create_seeders_table.js

@@ -0,0 +1,20 @@
+import Schema from "../../Schema/Manager.js";
+
+class CreateSeedersTable {
+
+    static async up() {
+        await Schema.create("seeders", (table) => {
+            table.id();
+            table.string("name").unique();
+            table.string("checksum", 64);
+            table.timestamp("executed_at");
+        });
+    }
+
+    static async down() {
+        await Schema.dropIfExists("seeders");
+    }
+
+}
+
+export default CreateSeedersTable;

package/lib/Database/Schema/Blueprint.js

@@ -1,7 +1,3 @@
-/**
- * Blueprint - Table schema builder
- * Laravel-style fluent API for defining database tables
- */
 class Blueprint {
     #tableName;
     #columns = [];
@@ -10,23 +6,14 @@ class Blueprint {
         this.#tableName = tableName;
     }
 
-    /**
-     * Get table name
-     */
     getTableName() {
         return this.#tableName;
     }
 
-    /**
-     * Get all columns
-     */
     getColumns() {
         return this.#columns;
     }
 
-    /**
-     * Add a column definition
-     */
     #addColumn(type, name, options = {}) {
         const column = {
             name,
@@ -41,7 +28,6 @@ class Blueprint {
 
         this.#columns.push(column);
 
-        // Return modifier object for chaining
         return {
             nullable: () => {
                 column.modifiers.nullable = true;
@@ -58,9 +44,6 @@ class Blueprint {
         };
     }
 
-    /**
-     * Primary key: BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY
-     */
     id() {
         const column = {
             name: 'id',
@@ -68,56 +51,33 @@ class Blueprint {
             modifiers: {}
         };
         this.#columns.push(column);
-        
-        // No chaining for id()
         return this;
     }
 
-    /**
-     * VARCHAR column
-     */
     string(name, length = 255) {
         return this.#addColumn('string', name, { length });
     }
 
-    /**
-     * TEXT column
-     */
     text(name) {
         return this.#addColumn('text', name);
     }
 
-    /**
-     * INT column
-     */
     integer(name) {
         return this.#addColumn('integer', name);
     }
 
-    /**
-     * BIGINT column
-     */
     bigInteger(name) {
         return this.#addColumn('bigInteger', name);
     }
 
-    /**
-     * TINYINT(1) column for boolean values
-     */
     boolean(name) {
         return this.#addColumn('boolean', name);
     }
 
-    /**
-     * TIMESTAMP column
-     */
     timestamp(name) {
         return this.#addColumn('timestamp', name);
     }
 
-    /**
-     * JSON column
-     */
     json(name) {
         return this.#addColumn('json', name);
     }

package/lib/Database/Schema/Manager.js

@@ -1,66 +1,59 @@
 import DatabaseManager from "../Manager.js";
 import Config from "../../Core/Config.js";
 
-/**
- * Schema Builder
- * Laravel-style database schema operations
- */
 export default class Schema {
-    /**
-     * Create a new table
-     */
+
     static async create(tableName, callback) {
         const blueprint = new (await import('./Blueprint.js')).default(tableName);
         callback(blueprint);
-        
-        const sql = this.#buildCreateTableSQL(blueprint);
-        
+
+        const sql = this.#buildCreateTableSQL(blueprint, false);
+
+        const connection = DatabaseManager.getInstance().connection();
+        await connection.raw(sql);
+    }
+
+    static async createIfNotExists(tableName, callback) {
+        const blueprint = new (await import('./Blueprint.js')).default(tableName);
+        callback(blueprint);
+
+        const sql = this.#buildCreateTableSQL(blueprint, true);
+
         const connection = DatabaseManager.getInstance().connection();
         await connection.raw(sql);
     }
-    
-    /**
-     * Drop table if exists
-     */
+
     static async dropIfExists(tableName) {
         const connection = DatabaseManager.getInstance().connection();
         await connection.raw(`DROP TABLE IF EXISTS \`${tableName}\``);
     }
-    
-    /**
-     * Build CREATE TABLE SQL
-     */
-    static #buildCreateTableSQL(blueprint) {
+
+    static #buildCreateTableSQL(blueprint, ifNotExists = false) {
         const columns = blueprint.getColumns();
         const columnsSql = columns.map(col => this.#buildColumnSQL(col));
-        
-        // Get connection config
+
         const manager = DatabaseManager.getInstance();
         const connection = manager.connection();
         const connectionName = connection.getName();
         const databaseConfig = Config.all('database');
         const dbConfig = databaseConfig.connections[connectionName];
-        
+
         const charset = dbConfig.charset || 'utf8mb4';
         const collation = dbConfig.collation || 'utf8mb4_unicode_ci';
-        
-        let sql = `CREATE TABLE \`${blueprint.getTableName()}\` (\n`;
+
+        const ifNotExistsClause = ifNotExists ? 'IF NOT EXISTS ' : '';
+        let sql = `CREATE TABLE ${ifNotExistsClause}\`${blueprint.getTableName()}\` (\n`;
         sql += '    ' + columnsSql.join(',\n    ');
         sql += `\n) ENGINE=InnoDB DEFAULT CHARSET=${charset} COLLATE=${collation}`;
-        
+
         return sql;
     }
-    
-    /**
-     * Build SQL for a single column
-     */
+
     static #buildColumnSQL(column) {
         let sql = `\`${column.name}\` `;
-        
-        // Type
+
         switch (column.type) {
             case 'id':
-                // id is special - no modifiers
                 sql += 'BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY';
                 return sql;
             case 'string':
@@ -87,30 +80,26 @@ export default class Schema {
             default:
                 throw new Error(`Unknown column type: ${column.type}`);
         }
-        
-        // Modifiers (not for id)
+
         if (column.modifiers) {
-            // NOT NULL / NULL
             if (column.modifiers.nullable) {
                 sql += ' NULL';
             } else {
                 sql += ' NOT NULL';
             }
-            
-            // DEFAULT
+
             if (column.modifiers.default !== null) {
                 const defaultValue = typeof column.modifiers.default === 'string'
                     ? `'${column.modifiers.default}'`
                     : column.modifiers.default;
                 sql += ` DEFAULT ${defaultValue}`;
             }
-            
-            // UNIQUE
+
             if (column.modifiers.unique) {
                 sql += ' UNIQUE';
             }
         }
-        
+
         return sql;
     }
 }