@nitronjs/framework 0.1.22 → 0.1.24

package/cli/njs.js

@@ -28,9 +28,14 @@ ${COLORS.bold}Development:${COLORS.reset}
 ${COLORS.bold}Database:${COLORS.reset}
   ${COLORS.cyan}njs migrate${COLORS.reset}               Run database migrations
   ${COLORS.cyan}njs migrate --seed${COLORS.reset}        Run migrations and seeders
+  ${COLORS.cyan}njs migrate:rollback${COLORS.reset}      Rollback the last batch of migrations
+  ${COLORS.cyan}njs migrate:status${COLORS.reset}        Show the status of each migration
   ${COLORS.cyan}njs migrate:fresh${COLORS.reset}         Drop all tables and re-migrate
   ${COLORS.cyan}njs migrate:fresh --seed${COLORS.reset}  Fresh migrate with seeders
-  ${COLORS.cyan}njs seed${COLORS.reset}                  Run database seeders
+  ${COLORS.cyan}njs seed${COLORS.reset}                  Run prod seeders
+  ${COLORS.cyan}njs seed --dev${COLORS.reset}            Run dev seeders
+  ${COLORS.cyan}njs seed --all${COLORS.reset}            Run all seeders (prod + dev)
+  ${COLORS.cyan}njs seed --status${COLORS.reset}         Show the status of each seeder
 
 ${COLORS.bold}Generators:${COLORS.reset}
   ${COLORS.cyan}njs make:controller${COLORS.reset}       Create a new controller
@@ -66,7 +71,7 @@ const additionalArgs = args.slice(1);
 
 const KNOWN_COMMANDS = [
     "dev", "start", "build",
-    "migrate", "migrate:fresh", "seed",
+    "migrate", "migrate:rollback", "migrate:status", "migrate:fresh", "seed",
     "storage:link",
     "make:controller", "make:middleware", "make:model", "make:migration", "make:seeder"
 ];
@@ -105,19 +110,42 @@ async function run() {
 
             case "migrate": {
                 const { default: Migrate } = await import("../lib/Console/Commands/MigrateCommand.js");
-                await Migrate(additionalArgs.includes("--seed"));
+                await Migrate({ seed: additionalArgs.includes("--seed") });
+                break;
+            }
+
+            case "migrate:rollback": {
+                const { default: Rollback } = await import("../lib/Console/Commands/MigrateRollbackCommand.js");
+                const stepArg = additionalArgs.find(arg => arg.startsWith('--step='));
+                const step = stepArg ? parseInt(stepArg.split('=')[1], 10) : 1;
+                const all = additionalArgs.includes('--all');
+                await Rollback({ step, all });
+                break;
+            }
+
+            case "migrate:status": {
+                const { default: Status } = await import("../lib/Console/Commands/MigrateStatusCommand.js");
+                await Status();
                 break;
             }
 
             case "migrate:fresh": {
                 const { default: MigrateFresh } = await import("../lib/Console/Commands/MigrateFreshCommand.js");
-                await MigrateFresh(additionalArgs.includes("--seed"));
+                await MigrateFresh({ seed: additionalArgs.includes("--seed") });
                 break;
             }
 
             case "seed": {
                 const { default: Seed } = await import("../lib/Console/Commands/SeedCommand.js");
-                await Seed();
+                const showStatus = additionalArgs.includes('--status');
+                const isDev = additionalArgs.includes('--dev');
+                const isAll = additionalArgs.includes('--all');
+
+                let environment = 'prod';
+                if (isDev) environment = 'dev';
+                if (isAll) environment = 'all';
+
+                await Seed({ environment, status: showStatus });
                 break;
             }
 

package/lib/Build/Manager.js

@@ -102,6 +102,7 @@ function wrapWithDepth(children) {
 
 function createIsland(Component, name) {
     function IslandBoundary(props) {
+        // Nested client components render normally (already inside an island)
         if (React.useContext(DepthContext)) {
             return OriginalJsx.jsx(Component, props);
         }
@@ -115,6 +116,8 @@ function createIsland(Component, name) {
             ctx.props[id] = safeProps;
         }
         
+        // SSR: Render full HTML for SEO and initial paint
+        // Client: Will re-render with createRoot for animations to work
         return OriginalJsx.jsx('div', {
             'data-cid': id,
             'data-island': name,
@@ -445,12 +448,16 @@ class Builder {
                 const importName = sanitizeName(baseName) + "_" + index++;
                 imports.push(`import ${importName} from "${relativePath}";`);
                 manifestEntries.push(`  "${baseName}": ${importName}`);
+                // Also add displayName entry
+                manifestEntries.push(`  [${importName}.displayName || ${importName}.name || "${baseName}"]: ${importName}`);
             }
 
             for (const namedExport of componentMeta.named || []) {
                 const importName = sanitizeName(namedExport) + "_" + index++;
                 imports.push(`import { ${namedExport} as ${importName} } from "${relativePath}";`);
                 manifestEntries.push(`  "${namedExport}": ${importName}`);
+                // Also add displayName entry
+                manifestEntries.push(`  [${importName}.displayName || ${importName}.name || "${namedExport}"]: ${importName}`);
             }
         }
 

package/lib/Console/Commands/MigrateCommand.js

@@ -1,95 +1,52 @@
-import fs from 'fs';
-import path from 'path';
-import { pathToFileURL } from 'url';
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
-import Paths from '../../Core/Paths.js';
 import Config from '../../Core/Config.js';
+import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
+import seed from './SeedCommand.js';
 
-class Migrate {
-    #files;
-    #shouldSeed;
+export default async function migrate(options = {}) {
+    const { seed: shouldSeed = false } = options;
 
-    constructor(files = null, shouldSeed = false) {
-        const migrationsDir = Paths.migrations;
-        this.#files = files || fs.readdirSync(migrationsDir);
-        this.#shouldSeed = shouldSeed;
+    dotenv.config({ quiet: true });
+    await Config.initialize();
+
+    try {
+        await DB.setup();
+    } catch (error) {
+        console.error('❌ Database setup failed:', error.message);
+        console.error('Check your .env file and ensure the database exists and is accessible');
+        return false;
     }
 
-    async run() {
-        dotenv.config({ quiet: true });
-        await Config.initialize();
-        
-        try {
-            await DB.setup();
-        } catch (error) {
-            console.error('❌ Database setup failed:', error.message);
-            console.error('Check your .env file and ensure the database exists and is accessible');
-            return false;
-        }
+    try {
+        const result = await MigrationRunner.run();
 
-        const migrationsDir = Paths.migrations;
-        for (const file of this.#files) {
-            const filePath = Paths.migrationUrl(file);
-            const module = await import(filePath);
-            
-            console.log(`📦 [\x1b[36m${module.default.name}\x1b[0m] Creating table...`);
-            try {
-                await module.default.up();
-                console.log(`✅ [\x1b[36m${module.default.name}\x1b[0m] Table created successfully\n`);
-            } catch (error) {
-                if (this.#isTableExistsError(error)) {
-                    console.log(`⚠️  [\x1b[36m${module.default.name}\x1b[0m] Table already exists, skipping\n`);
-                    continue;
-                }
-                throw error;
-            }
+        if (!result.success) {
+            await DB.close();
+            return false;
         }
 
-        if (this.#shouldSeed) {
-            await this.#runSeeders();
+        if (shouldSeed && result.ran.length > 0) {
+            console.log('\n');
+            await seed();
         }
 
         await DB.close();
         return true;
-    }
-
-    async #runSeeders() {
-        const seedersDir = Paths.seeders;
-        const seedFiles = fs.readdirSync(seedersDir);
-
-        for (const file of seedFiles) {
-            const filePath = pathToFileURL(path.join(seedersDir, file)).href;
-            const seeder = await import(filePath);
-            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
-            await seeder.default.run();
-            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
-        }
-    }
 
-    #isTableExistsError(error) {
-        const message = String(error?.message || "").toLowerCase();
-
-        return message.includes("already exists") ||
-            message.includes("table exists") ||
-            message.includes("errno 1050") ||
-            message.includes("er_table_exists_error") ||
-            message.includes("duplicate table");
+    } catch (error) {
+        console.error('❌ Migration error:', error.message);
+        await DB.close();
+        return false;
     }
 }
 
-export default async function migrate(shouldSeed = false, files = null) {
-    const instance = new Migrate(files, shouldSeed);
-    return instance.run();
-}
-
-// Auto-run when called directly
 const isMain = process.argv[1]?.endsWith("MigrateCommand.js");
 if (isMain) {
     const args = process.argv.slice(2);
     const shouldSeed = args.includes("--seed");
-    const files = args.filter(arg => arg !== "--seed");
-    migrate(shouldSeed, files.length > 0 ? files : null)
+
+    migrate({ seed: shouldSeed })
         .then(success => process.exit(success ? 0 : 1))
         .catch(err => {
             console.error(err);

package/lib/Console/Commands/MigrateFreshCommand.js

@@ -1,94 +1,77 @@
-import fs from 'fs';
-import path from 'path';
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
-import Paths from '../../Core/Paths.js';
 import Config from '../../Core/Config.js';
+import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
+import seed from './SeedCommand.js';
 
-class MigrateFresh {
-    #shouldSeed;
+const COLORS = {
+    reset: '\x1b[0m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    dim: '\x1b[2m'
+};
 
-    constructor(shouldSeed = false) {
-        this.#shouldSeed = shouldSeed;
+export default async function migrateFresh(options = {}) {
+    const { seed: shouldSeed = false } = options;
+
+    dotenv.config({ quiet: true });
+    await Config.initialize();
+
+    try {
+        await DB.setup();
+    } catch (error) {
+        console.error('❌ Database setup failed:', error.message);
+        console.error('Check your .env file and ensure the database exists and is accessible');
+        return false;
     }
 
-    async run() {
-        dotenv.config({ quiet: true });
-        await Config.initialize();
-        
-        try {
-            await DB.setup();
-        }
-        catch (error) {
-            console.error('❌ Database setup failed:', error.message);
-            console.error('Check your .env file and ensure the database exists and is accessible');
-            return false;
-        }
+    try {
+        console.log(`${COLORS.yellow}⚠️  Dropping all tables...${COLORS.reset}\n`);
 
-        await this.#dropAllTables();
-        await this.#runMigrations();
-        
-        if (this.#shouldSeed) {
-            await this.#runSeeders();
-        }
+        const [tableRows] = await DB.query("SHOW TABLES");
+        await DB.rawQuery("SET FOREIGN_KEY_CHECKS = 0");
 
-        await DB.close();
-        return true;
-    }
+        for (const row of tableRows) {
+            const tableName = Object.values(row)[0];
+            console.log(`${COLORS.dim}Dropping:${COLORS.reset} ${COLORS.cyan}${tableName}${COLORS.reset}`);
+            await DB.rawQuery(`DROP TABLE IF EXISTS \`${tableName}\``);
+        }
 
-    async #dropAllTables() {
-        const connection = await DB.connection();
-        const currentTables = await connection.query("SHOW TABLES");
-        await connection.query("SET FOREIGN_KEY_CHECKS = 0");
+        await DB.rawQuery("SET FOREIGN_KEY_CHECKS = 1");
 
-        for (const table of currentTables[0]) {
-            const tableName = Object.values(table)[0];
-            console.log(`❌ [\x1b[36m${tableName}\x1b[0m] Dropping table...`);
-            await connection.query(`DROP TABLE IF EXISTS \`${tableName}\``);
-            console.log(`✅ [\x1b[36m${tableName}\x1b[0m] Table dropped\n`);
+        if (tableRows.length > 0) {
+            console.log(`\n${COLORS.green}✅ Dropped ${tableRows.length} table(s)${COLORS.reset}\n`);
         }
 
-        await connection.query("SET FOREIGN_KEY_CHECKS = 1");
-    }
+        const result = await MigrationRunner.run();
 
-    async #runMigrations() {
-        const migrationsDir = Paths.migrations;
-        const files = fs.readdirSync(migrationsDir);
+        if (!result.success) {
+            await DB.close();
+            return false;
+        }
 
-        for (const file of files) {
-            const filePath = Paths.migrationUrl(file);
-            const module = await import(filePath);
-            console.log(`📦 [\x1b[36m${module.default.name}\x1b[0m] Creating table...`);
-            await module.default.up();
-            console.log(`✅ [\x1b[36m${module.default.name}\x1b[0m] Table created successfully\n`);
+        if (shouldSeed && result.ran.length > 0) {
+            console.log('\n');
+            await seed();
         }
-    }
 
-    async #runSeeders() {
-        const seedersDir = Paths.seeders;
-        const seedFiles = fs.readdirSync(seedersDir);
+        await DB.close();
+        return true;
 
-        for (const file of seedFiles) {
-            const filePath = Paths.seederUrl(file);
-            const seeder = await import(filePath);
-            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
-            await seeder.default.run();
-            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
-        }
+    } catch (error) {
+        console.error('❌ Fresh migration error:', error.message);
+        await DB.close();
+        return false;
     }
 }
 
-export default async function migrateFresh(shouldSeed = false) {
-    const instance = new MigrateFresh(shouldSeed);
-    return instance.run();
-}
-
-// Auto-run when called directly
 const isMain = process.argv[1]?.endsWith("MigrateFreshCommand.js");
 if (isMain) {
     const args = process.argv.slice(2);
     const shouldSeed = args.includes("--seed");
-    migrateFresh(shouldSeed)
+
+    migrateFresh({ seed: shouldSeed })
         .then(success => process.exit(success ? 0 : 1))
         .catch(err => {
             console.error(err);

package/lib/Console/Commands/MigrateRollbackCommand.js

@@ -0,0 +1,52 @@
+import dotenv from 'dotenv';
+import DB from '../../Database/DB.js';
+import Config from '../../Core/Config.js';
+import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
+
+export default async function rollback(options = {}) {
+    const { step = 1, all = false } = options;
+
+    dotenv.config({ quiet: true });
+    await Config.initialize();
+
+    try {
+        await DB.setup();
+    } catch (error) {
+        console.error('❌ Database setup failed:', error.message);
+        console.error('Check your .env file and ensure the database exists and is accessible');
+        return false;
+    }
+
+    try {
+        let result;
+
+        if (all) {
+            result = await MigrationRunner.reset();
+        } else {
+            result = await MigrationRunner.rollback(step);
+        }
+
+        await DB.close();
+        return result.success;
+
+    } catch (error) {
+        console.error('❌ Rollback error:', error.message);
+        await DB.close();
+        return false;
+    }
+}
+
+const isMain = process.argv[1]?.endsWith("MigrateRollbackCommand.js");
+if (isMain) {
+    const args = process.argv.slice(2);
+    const stepArg = args.find(arg => arg.startsWith('--step='));
+    const step = stepArg ? parseInt(stepArg.split('=')[1], 10) : 1;
+    const all = args.includes('--all');
+
+    rollback({ step, all })
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+}

package/lib/Console/Commands/MigrateStatusCommand.js

@@ -0,0 +1,38 @@
+import dotenv from 'dotenv';
+import DB from '../../Database/DB.js';
+import Config from '../../Core/Config.js';
+import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
+
+export default async function status() {
+    dotenv.config({ quiet: true });
+    await Config.initialize();
+
+    try {
+        await DB.setup();
+    } catch (error) {
+        console.error('❌ Database setup failed:', error.message);
+        console.error('Check your .env file and ensure the database exists and is accessible');
+        return false;
+    }
+
+    try {
+        await MigrationRunner.printStatus();
+        await DB.close();
+        return true;
+
+    } catch (error) {
+        console.error('❌ Status error:', error.message);
+        await DB.close();
+        return false;
+    }
+}
+
+const isMain = process.argv[1]?.endsWith("MigrateStatusCommand.js");
+if (isMain) {
+    status()
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+}

package/lib/Console/Commands/SeedCommand.js

@@ -1,89 +1,60 @@
-#!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
-import Paths from '../../Core/Paths.js';
 import Config from '../../Core/Config.js';
+import SeederRunner from '../../Database/Seeder/SeederRunner.js';
 
-class Seed {
-    #seederClass;
+export default async function seed(options = {}) {
+    const { environment = 'prod', status = false } = options;
 
-    constructor(seederClass = null) {
-        this.#seederClass = seederClass;
+    dotenv.config({ quiet: true });
+    await Config.initialize();
+
+    try {
+        await DB.setup();
+    } catch (error) {
+        console.error('❌ Database setup failed:', error.message);
+        console.error('Check your .env file and ensure the database exists and is accessible');
+        return false;
     }
 
-    async run() {
-        dotenv.config({ quiet: true });
-        await Config.initialize();
-        
-        try {
-            await DB.setup();
-        } catch (error) {
-            console.error('❌ Database setup failed:', error.message);
-            console.error('Check your .env file and ensure the database exists and is accessible');
-            return false;
+    try {
+        if (status) {
+            await SeederRunner.printStatus();
+            await DB.close();
+            return true;
         }
 
-        if (this.#seederClass) {
-            await this.#runSeeder(this.#seederClass);
+        let result;
+
+        if (environment === 'all') {
+            result = await SeederRunner.runAll();
         } else {
-            await this.#runAllSeeders();
+            result = await SeederRunner.run(environment);
         }
 
         await DB.close();
-        return true;
-    }
-
-    async #runSeeder(className) {
-        const file = className + ".js";
-        const filePath = Paths.seederUrl(file);
-        
-        try {
-            const seeder = await import(filePath);
-            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
-            await seeder.default.run();
-            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
-        } catch (error) {
-            console.error(`❌ Seeder '${className}' not found or failed:`, error.message);
-            throw error;
-        }
-    }
+        return result.success;
 
-    async #runAllSeeders() {
-        const seedersDir = Paths.seeders;
-        const seedFiles = fs.readdirSync(seedersDir);
-
-        if (seedFiles.length === 0) {
-            console.log("No seeders found in database/seeders");
-            return;
-        }
-
-        for (const file of seedFiles) {
-            const filePath = Paths.seederUrl(file);
-            const seeder = await import(filePath);
-            console.log(`🌱 [\x1b[36m${seeder.default.name}\x1b[0m] Seeding...`);
-            await seeder.default.run();
-            console.log(`✅ [\x1b[36m${seeder.default.name}\x1b[0m] Seeding completed\n`);
-        }
+    } catch (error) {
+        console.error('❌ Seeding error:', error.message);
+        await DB.close();
+        return false;
     }
 }
 
-export default async function seed(seederClass = null) {
-    const instance = new Seed(seederClass);
-    return instance.run();
-}
-
-// Auto-run when called directly
 const isMain = process.argv[1]?.endsWith("SeedCommand.js");
 if (isMain) {
     const args = process.argv.slice(2);
-    const classArg = args.find(arg => arg.startsWith('--class='));
-    const seederClass = classArg 
-        ? classArg.split('=')[1] 
-        : (args[0] && !args[0].startsWith('-') ? args[0] : null);
 
-    seed(seederClass)
+    const showStatus = args.includes('--status');
+    const isDev = args.includes('--dev');
+    const isAll = args.includes('--all');
+
+    let environment = 'prod';
+    if (isDev) environment = 'dev';
+    if (isAll) environment = 'all';
+
+    seed({ environment, status: showStatus })
         .then(success => process.exit(success ? 0 : 1))
         .catch(err => {
             console.error(err);

package/lib/Console/Stubs/page-hydration.tsx

@@ -1,5 +1,5 @@
 import React from "react";
-import { hydrateRoot } from "react-dom/client";
+import { createRoot } from "react-dom/client";
 
 // __COMPONENT_IMPORTS__
 
@@ -13,7 +13,7 @@ const componentManifest: Record<string, React.ComponentType<any>> = {};
 
 // __COMPONENT_MANIFEST__
 
-function hydrate() {
+function mount() {
     const props = window.__NITRON_PROPS__ || {};
 
     const islands = document.querySelectorAll<HTMLElement>("[data-cid]");
@@ -35,11 +35,10 @@ function hydrate() {
         const componentProps = props[componentId] || {};
 
         try {
-            hydrateRoot(
-                element,
-                React.createElement(Component, componentProps),
-                { identifierPrefix: componentId }
-            );
+            // Use createRoot for full client-side rendering
+            // This ensures animations and effects work correctly
+            const root = createRoot(element);
+            root.render(React.createElement(Component, componentProps));
         } catch {
         }
     });
@@ -48,7 +47,8 @@ function hydrate() {
 }
 
 if (document.readyState === "loading") {
-    document.addEventListener("DOMContentLoaded", hydrate);
+    document.addEventListener("DOMContentLoaded", mount);
 } else {
-    hydrate();
+    mount();
 }
+

package/lib/Core/Paths.js

@@ -92,6 +92,14 @@ 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/Migration/Checksum.js

@@ -0,0 +1,23 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+
+class Checksum {
+
+    static fromFile(filePath) {
+        const content = fs.readFileSync(filePath, 'utf8');
+        return this.fromContent(content);
+    }
+
+    static fromContent(content) {
+        const normalized = content.replace(/\r\n/g, '\n').trim();
+        return createHash('sha256').update(normalized, 'utf8').digest('hex');
+    }
+
+    static verify(filePath, expectedChecksum) {
+        const actualChecksum = this.fromFile(filePath);
+        return actualChecksum === expectedChecksum;
+    }
+
+}
+
+export default Checksum;