@nitronjs/framework 0.1.21 → 0.1.23

package/cli/create.js

@@ -32,6 +32,27 @@ function logStep(message, status = "pending") {
     console.log(`  ${icons[status]} ${message}`);
 }
 
+function startSpinner(message) {
+    if (!process.stdout.isTTY) {
+        return () => {};
+    }
+
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let i = 0;
+    const line = () => `  ${COLORS.yellow}${frames[i]}${COLORS.reset} ${message}`;
+
+    process.stdout.write(line());
+    const timer = setInterval(() => {
+        i = (i + 1) % frames.length;
+        process.stdout.write(`\r${line()}`);
+    }, 120);
+
+    return () => {
+        clearInterval(timer);
+        process.stdout.write(`\r${" ".repeat(message.length + 4)}\r`);
+    };
+}
+
 function printBanner() {
     console.log();
     log("███╗   ██╗██╗████████╗██████╗  ██████╗ ███╗   ██╗     ██╗███████╗", COLORS.cyan);
@@ -150,12 +171,12 @@ function updateEnvFile(projectPath) {
 function runNpmInstall(projectPath) {
     return new Promise((resolve, reject) => {
         const isWindows = process.platform === "win32";
-        const npm = isWindows ? "npm.cmd" : "npm";
+        const npm = isWindows ? (process.env.ComSpec || "cmd.exe") : "npm";
+        const npmArgs = isWindows ? ["/d", "/s", "/c", "npm", "install"] : ["install"];
         
-        const child = spawn(npm, ["install"], {
+        const child = spawn(npm, npmArgs, {
             cwd: projectPath,
-            stdio: ["ignore", "pipe", "pipe"],
-            shell: isWindows
+            stdio: ["ignore", "pipe", "pipe"]
         });
 
         let output = "";
@@ -262,10 +283,13 @@ export default async function create(projectName, options = {}) {
     logStep("APP_KEY generated", "success");
 
     logStep("Installing dependencies (this may take a moment)...", "running");
+    const stopSpinner = startSpinner("Installing dependencies...");
     try {
         await runNpmInstall(projectPath);
+        stopSpinner();
         logStep("Dependencies installed", "success");
     } catch (error) {
+        stopSpinner();
         logStep("Failed to install dependencies", "error");
         if (error.output) {
             log(`${COLORS.dim}${error.output}${COLORS.reset}`);

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/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/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;