@nitronjs/framework 0.1.0

package/lib/Console/Commands/BuildCommand.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import Builder from "../../Build/Manager.js";
+
+export default async function Build(only = null) {
+    const builder = new Builder();
+
+    try {
+        const success = await builder.run(only);
+        return success;
+    } catch (error) {
+        console.error("Build failed:", error.message);
+        throw error;
+    }
+}
+
+// Auto-run when called directly
+const isMain = process.argv[1]?.endsWith("BuildCommand.js");
+if (isMain) {
+    // process.argv[2] would be --only=views or --only=css
+    const onlyArg = process.argv.find(arg => arg.startsWith("--only="));
+    const only = onlyArg?.split("=")[1] || null;
+    Build(only)
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(() => process.exit(1));
+}

package/lib/Console/Commands/DevCommand.js

@@ -0,0 +1,385 @@
+#!/usr/bin/env node
+import dotenv from "dotenv";
+import { spawn } from "child_process";
+import chokidar from "chokidar";
+import path from "path";
+import Paths from "../../Core/Paths.js";
+
+dotenv.config({ quiet: true });
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Constants
+// ─────────────────────────────────────────────────────────────────────────────
+
+const FRAMEWORK_DIR = Paths.framework;
+const PROJECT_DIR = Paths.project;
+
+const COLORS = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m"
+};
+
+// Watch configuration (relative to PROJECT_DIR)
+const WATCH_CONFIG = {
+    // Files that trigger only a build (no server restart)
+    // Controllers are hot-reloaded via dynamic import in dev mode
+    buildOnly: [
+        "resources/views/**/*.tsx",
+        "resources/views/**/*.ts",
+        "resources/css/**/*.css",
+        "app/Controllers/*.js",
+        "app/Middlewares/*.js",
+        "app/Middlewares/**/*.js"
+    ],
+    
+    // Files that trigger a full server restart
+    fullRestart: [
+        "config/**/*.js",
+        "app/Kernel.js",
+        "app/Models/**/*.js",
+        "routes/**/*.js",
+        "app.js"
+    ],
+    
+    // Framework files (relative to FRAMEWORK_DIR) - trigger build only
+    frameworkBuildOnly: [
+        "lib/View/Templates/**/*.tsx",
+        "lib/View/Templates/**/*.ts"
+    ],
+    
+    // Ignored patterns
+    ignore: [
+        "**/node_modules/**",
+        "**/build/**",
+        "**/storage/app/public/**",
+        "**/storage/framework/**",
+        "**/storage/logs/**",
+        "**/.nitron/**",
+        "**/.git/**",
+        "**/package-lock.json"
+    ]
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Dev Server Class
+// ─────────────────────────────────────────────────────────────────────────────
+
+class DevServer {
+    #serverProcess = null;
+    #isBuilding = false;
+    #pendingRestart = false;
+    #pendingBuild = false;
+    #buildDebounceTimer = null;
+    #restartDebounceTimer = null;
+    #watcherReady = false;
+
+    constructor() {
+        //
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Logging
+    // ─────────────────────────────────────────────────────────────────────────
+
+    #log(type, message, details = null) {
+        const now = new Date();
+        const time = `${COLORS.dim}${now.toLocaleTimeString()}${COLORS.reset}`;
+        
+        const icons = {
+            info:    `${COLORS.blue}[i]${COLORS.reset}`,
+            success: `${COLORS.green}[✓]${COLORS.reset}`,
+            warning: `${COLORS.yellow}[!]${COLORS.reset}`,
+            error:   `${COLORS.red}[✗]${COLORS.reset}`,
+            build:   `${COLORS.magenta}[~]${COLORS.reset}`,
+            reload:  `${COLORS.cyan}[↻]${COLORS.reset}`,
+            watch:   `${COLORS.yellow}[○]${COLORS.reset}`
+        };
+
+        const icon = icons[type] || icons.info;
+        let output = `${time} ${icon} ${message}`;
+        
+        if (details) {
+            output += ` ${COLORS.dim}(${details})${COLORS.reset}`;
+        }
+        
+        console.log(output);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Build Process
+    // ─────────────────────────────────────────────────────────────────────────
+
+    async #runBuild(buildArg = null) {
+        if (this.#isBuilding) {
+            this.#pendingBuild = true;
+            return false;
+        }
+
+        this.#isBuilding = true;
+        const startTime = Date.now();
+        this.#log("build", "Building...");
+
+        return new Promise((resolve) => {
+            const buildScript = path.join(FRAMEWORK_DIR, "lib/Console/Commands/BuildCommand.js");
+            const args = [buildScript];
+            if (buildArg) args.push(buildArg);
+            
+            const buildProcess = spawn(process.execPath, args, {
+                cwd: PROJECT_DIR,
+                stdio: ["inherit", "pipe", "pipe"]
+            });
+
+            let output = "";
+
+            buildProcess.stdout.on("data", (data) => {
+                output += data.toString();
+            });
+
+            buildProcess.stderr.on("data", (data) => {
+                output += data.toString();
+            });
+
+            buildProcess.on("close", (code) => {
+                this.#isBuilding = false;
+                const duration = Date.now() - startTime;
+
+                if (code === 0) {
+                    this.#log("success", `Build completed`, `${duration}ms`);
+                    
+                    if (this.#pendingBuild) {
+                        this.#pendingBuild = false;
+                        this.#runBuild().then(resolve);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                }
+                else {
+                    this.#log("error", "Build failed");
+                    console.log(output);
+                    resolve(false);
+                }
+            });
+        });
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // Server Process Management
+    // ─────────────────────────────────────────────────────────────────────────
+
+    async #startServer() {
+        return new Promise((resolve) => {
+            const entryScript = path.join(FRAMEWORK_DIR, "lib/Runtime/Entry.js");
+            
+            this.#serverProcess = spawn(process.execPath, [entryScript], {
+                cwd: PROJECT_DIR,
+                stdio: ["inherit", "inherit", "inherit"],
+                env: { ...process.env, APP_DEV: "true" }
+            });
+
+            this.#serverProcess.on("error", (err) => {
+                this.#log("error", `Server error: ${err.message}`);
+            });
+
+            this.#serverProcess.on("close", (code) => {
+                if (code !== 0 && code !== null && !this.#pendingRestart) {
+                    this.#log("error", `Server exited with code ${code}`);
+                }
+                this.#serverProcess = null;
+            });
+
+            setTimeout(() => resolve(), 500);
+        });
+    }
+
+    async #stopServer() {
+        if (!this.#serverProcess) return;
+
+        return new Promise((resolve) => {
+            
+            const forceKillTimer = setTimeout(() => {
+                if (this.#serverProcess) {
+                    this.#serverProcess.kill("SIGKILL");
+                }
+                resolve();
+            }, 5000);
+
+            this.#serverProcess.once("close", () => {
+                clearTimeout(forceKillTimer);
+                resolve();
+            });
+
+            this.#serverProcess.kill("SIGTERM");
+        });
+    }
+
+    async #restartServer() {
+        if (this.#pendingRestart) return;
+        
+        this.#pendingRestart = true;
+        await this.#stopServer();
+        await this.#startServer();
+        this.#pendingRestart = false;
+    }
+
+    #getRelativePath(filePath, baseDir = PROJECT_DIR) {
+        return path.relative(baseDir, filePath).replace(/\\/g, "/");
+    }
+
+    #matchesPattern(filePath, patterns, baseDir = PROJECT_DIR) {
+        const relativePath = this.#getRelativePath(filePath, baseDir);
+        
+        return patterns.some(pattern => {
+            let regexPattern = pattern
+                .replace(/\*\*\//g, "<<ANYDIR>>")     // **/ = any directory depth
+                .replace(/\*\*/g, "<<ANYCHAR>>")      // ** = any characters
+                .replace(/\*/g, "[^/]*")              // * = any characters except /
+                .replace(/\//g, "\\/")                // escape forward slashes
+                .replace(/<<ANYDIR>>/g, "(?:.*\\/)?") // restore **/ placeholder
+                .replace(/<<ANYCHAR>>/g, ".*");       // restore ** placeholder
+            
+            const regex = new RegExp(`^${regexPattern}$`);
+            return regex.test(relativePath);
+        });
+    }
+
+    async #handleFileChange(filePath, eventType) {
+        const relativePath = this.#getRelativePath(filePath);
+        const frameworkRelativePath = this.#getRelativePath(filePath, FRAMEWORK_DIR);
+        
+        // Check framework files first (lib/View/Templates)
+        if (this.#matchesPattern(filePath, WATCH_CONFIG.frameworkBuildOnly, FRAMEWORK_DIR)) {
+            this.#log("reload", `Framework file changed: ${frameworkRelativePath}`);
+            
+            clearTimeout(this.#buildDebounceTimer);
+            this.#buildDebounceTimer = setTimeout(async () => {
+                await this.#runBuild();
+            }, 100);
+            
+            return;
+        }
+        
+        // Check project build-only files
+        if (this.#matchesPattern(filePath, WATCH_CONFIG.buildOnly)) {
+            this.#log("reload", `File changed: ${relativePath}`);
+            // CSS only needs CSS rebuild
+            // TSX needs views + CSS (Tailwind scans TSX for classes)
+            const isCss = filePath.endsWith(".css");
+            const buildArg = isCss ? "--only=css" : null; // null = full build for TSX
+            
+            clearTimeout(this.#buildDebounceTimer);
+            this.#buildDebounceTimer = setTimeout(async () => {
+                await this.#runBuild(buildArg);
+            }, 100);
+            
+            return;
+        }
+
+        if (this.#matchesPattern(filePath, WATCH_CONFIG.fullRestart)) {
+            this.#log("reload", `File changed: ${relativePath}`, "full restart");
+            
+            clearTimeout(this.#restartDebounceTimer);
+            this.#restartDebounceTimer = setTimeout(async () => {
+                await this.#runBuild();
+                await this.#restartServer();
+            }, 200);
+            
+            return;
+        }
+    }
+
+    #setupWatcher() {
+        const watchPaths = [
+            path.join(PROJECT_DIR, "resources/views"),
+            path.join(PROJECT_DIR, "resources/css"),
+            path.join(FRAMEWORK_DIR, "lib/View/Templates"),
+            path.join(PROJECT_DIR, "config"),
+            path.join(PROJECT_DIR, "app"),
+            path.join(PROJECT_DIR, "routes"),
+            path.join(PROJECT_DIR, "app.js")
+        ];
+
+        const watcher = chokidar.watch(watchPaths, {
+            ignored: [
+                /node_modules/,
+                /\.git/,
+                /build[\\\/]/,
+                /storage[\\\/]app[\\\/]public/,
+                /storage[\\\/]framework/,
+                /storage[\\\/]logs/,
+                /\.nitron/,
+                /package-lock\.json$/
+            ],
+            persistent: true,
+            ignoreInitial: true,
+            usePolling: false,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50
+            }
+        });
+
+        watcher.on("change", (filePath) => this.#handleFileChange(filePath, "change"));
+        watcher.on("add", (filePath) => this.#handleFileChange(filePath, "add"));
+        watcher.on("unlink", (filePath) => this.#handleFileChange(filePath, "unlink"));
+
+        watcher.on("ready", () => {
+            if (!this.#watcherReady) {
+                this.#watcherReady = true;
+                this.#log("watch", "Watching for file changes...");
+            }
+        });
+
+        watcher.on("error", (error) => {
+            this.#log("error", `Watcher error: ${error.message}`);
+        });
+
+        return watcher;
+    }
+
+    async start() {
+        // Initial build
+        const buildSuccess = await this.#runBuild();
+        if (!buildSuccess) {
+            this.#log("error", "Initial build failed. Watching for changes...");
+        }
+
+        // Start server
+        await this.#startServer();
+
+        // Setup file watcher
+        const watcher = this.#setupWatcher();
+
+        // Graceful shutdown
+        const cleanup = async () => {
+            console.log();
+            watcher.close();
+            await this.#stopServer();
+            process.exit(0);
+        };
+
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    }
+}
+
+export default async function Dev() {
+    const devServer = new DevServer();
+    await devServer.start();
+}
+
+// Auto-run when called directly
+const isMain = process.argv[1]?.endsWith("DevCommand.js");
+if (isMain) {
+    Dev().catch(err => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/lib/Console/Commands/MakeCommand.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import Paths from '../../Core/Paths.js';
+
+const baseDirs = {
+    controller: 'app/Controllers',
+    middleware: 'app/Middlewares',
+    model: 'app/Models',
+    migration: 'database/migrations',
+    seeder: 'database/seeders',
+};
+
+const templates = {
+    controller: 'controller.js',
+    middleware: 'middleware.js',
+    model: 'model.js',
+    migration: 'migration.js',
+    seeder: 'seeder.js',
+};
+
+function toTableName(className) {
+    const name = className.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+    return pluralize(name);
+}
+
+function pluralize(word) {
+    if (/[^aeiou]y$/.test(word)) {
+        return word.slice(0, -1) + 'ies';
+    }
+
+    if (/(s|x|z|ch|sh)$/.test(word)) {
+        return word + 'es';
+    }
+
+    if (/fe?$/.test(word)) {
+        return word.replace(/fe?$/, 'ves');
+    }
+
+    return word.endsWith('s') ? word : word + 's';
+}
+
+function toPascalCase(str) {
+    return str
+        .split(/[-_]/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+
+export default async function make(type, rawName) {
+    if (!type || !rawName) {
+        console.error("\x1b[31m%s\x1b[0m", "Usage: njs make:<type> <Name/Path>  (e.g., njs make:controller Admin/HomeController)");
+        return false;
+    }
+
+    const parts = rawName.split('/');
+    const subDirs = parts.slice(0, -1).join('/');
+    const outputDir = path.join(Paths.project, baseDirs[type]);
+
+    let className = parts[parts.length - 1];
+    let fileName = `${className}.js`;
+
+    if (type === 'migration') {
+        const now = new Date();
+        const pad = (n) => n.toString().padStart(2, '0');
+
+        const year = now.getFullYear();
+        const month = pad(now.getMonth() + 1);
+        const day = pad(now.getDate());
+        const hour = pad(now.getHours());
+        const minute = pad(now.getMinutes());
+
+        const timestamp = `${year}_${month}_${day}_${hour}_${minute}`;
+        fileName = `${timestamp}_${className}.js`;
+    }
+
+    const fullDir = path.join(outputDir, subDirs);
+    const fullPath = path.join(fullDir, fileName);
+
+    const templatePath = path.join(Paths.frameworkTemplates, templates[type]);
+    let template = fs.readFileSync(templatePath, 'utf-8');
+
+    if (type === "model") {
+        template = template.replace(/__CLASS__/g, className).replace(/__TABLE__/g, toTableName(className));
+    }
+    else if (type === "migration") {
+        template = template.replace(/__CLASS__/g, toPascalCase(className)).replace(/__TABLE__/g, className);
+    }
+    else {
+        template = template.replace(/__CLASS__/g, className);
+    }
+
+    fs.mkdirSync(fullDir, { recursive: true });
+    fs.writeFileSync(fullPath, template);
+
+    console.log("\x1b[32m%s\x1b[0m", `${type[0].toUpperCase() + type.slice(1)} successfully created: ${fullPath}`);
+    return true;
+}
+
+// Auto-run when called directly
+const isMain = process.argv[1]?.endsWith("MakeCommand.js");
+if (isMain) {
+    const [, , type, rawName] = process.argv;
+    make(type, rawName)
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+}

package/lib/Console/Commands/MigrateCommand.js

@@ -0,0 +1,98 @@
+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';
+
+class Migrate {
+    #files;
+    #shouldSeed;
+
+    constructor(files = null, shouldSeed = false) {
+        const migrationsDir = Paths.migrations;
+        this.#files = files || fs.readdirSync(migrationsDir);
+        this.#shouldSeed = shouldSeed;
+    }
+
+    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;
+        }
+
+        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 (this.#shouldSeed) {
+            await this.#runSeeders();
+        }
+
+        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");
+    }
+}
+
+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)
+        .then(success => process.exit(success ? 0 : 1))
+        .catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+}