@nitronjs/framework 0.2.19 → 0.2.20

package/cli/njs.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const COLORS = {
     reset: "\x1b[0m",
@@ -87,14 +87,18 @@ async function run() {
             return;
         }
 
+        let exitCode = null;
+
         switch (command) {
             case "dev": {
+                import("../lib/Console/UpdateChecker.js").then(m => m.default());
                 const { default: Dev } = await import("../lib/Console/Commands/DevCommand.js");
                 await Dev();
                 break;
             }
 
             case "start": {
+                import("../lib/Console/UpdateChecker.js").then(m => m.default());
                 const { default: Start } = await import("../lib/Console/Commands/StartCommand.js");
                 await Start();
                 break;
@@ -103,13 +107,13 @@ async function run() {
             case "build": {
                 const { default: Build } = await import("../lib/Console/Commands/BuildCommand.js");
                 await Build();
+                exitCode = 0;
                 break;
             }
 
             case "migrate": {
                 const { default: Migrate } = await import("../lib/Console/Commands/MigrateCommand.js");
-                const success = await Migrate({ seed: additionalArgs.includes("--seed") });
-                process.exit(success ? 0 : 1);
+                exitCode = (await Migrate({ seed: additionalArgs.includes("--seed") })) ? 0 : 1;
                 break;
             }
 
@@ -118,37 +122,33 @@ async function run() {
                 const stepArg = additionalArgs.find(arg => arg.startsWith('--step='));
                 const step = stepArg ? parseInt(stepArg.split('=')[1], 10) : 1;
                 const all = additionalArgs.includes('--all');
-                const success = await Rollback({ step, all });
-                process.exit(success ? 0 : 1);
+                exitCode = (await Rollback({ step, all })) ? 0 : 1;
                 break;
             }
 
             case "migrate:status": {
                 const { default: Status } = await import("../lib/Console/Commands/MigrateStatusCommand.js");
                 await Status();
-                process.exit(0);
+                exitCode = 0;
                 break;
             }
 
             case "migrate:fresh": {
                 const { default: MigrateFresh } = await import("../lib/Console/Commands/MigrateFreshCommand.js");
-                const success = await MigrateFresh({ seed: additionalArgs.includes("--seed") });
-                process.exit(success ? 0 : 1);
+                exitCode = (await MigrateFresh({ seed: additionalArgs.includes("--seed") })) ? 0 : 1;
                 break;
             }
 
             case "seed": {
                 const { default: Seed } = await import("../lib/Console/Commands/SeedCommand.js");
                 const seederName = additionalArgs.find(a => !a.startsWith('--')) || null;
-                const success = await Seed(seederName);
-                process.exit(success ? 0 : 1);
+                exitCode = (await Seed(seederName)) ? 0 : 1;
                 break;
             }
 
             case "storage:link": {
                 const { default: StorageLink } = await import("../lib/Console/Commands/StorageLinkCommand.js");
-                const success = await StorageLink();
-                process.exit(success ? 0 : 1);
+                exitCode = (await StorageLink()) ? 0 : 1;
                 break;
             }
 
@@ -168,8 +168,7 @@ async function run() {
                 }
 
                 const { default: Make } = await import("../lib/Console/Commands/MakeCommand.js");
-                const success = await Make(type, name);
-                process.exit(success ? 0 : 1);
+                exitCode = (await Make(type, name)) ? 0 : 1;
                 break;
             }
 
@@ -178,6 +177,12 @@ async function run() {
                 console.log(`${COLORS.dim}Run 'njs --help' for available commands${COLORS.reset}`);
                 process.exit(1);
         }
+
+        if (exitCode !== null) {
+            const { default: checkForUpdates } = await import("../lib/Console/UpdateChecker.js");
+            await checkForUpdates();
+            process.exit(exitCode);
+        }
     } catch (error) {
         console.error(`${COLORS.red}Error: ${error.message}${COLORS.reset}`);
         if (process.env.DEBUG) {

package/lib/Build/jsxRuntime.js

@@ -85,29 +85,45 @@ function wrapWithDepth(children) {
 }
 
 // Deep Proxy that tracks which prop paths are accessed during SSR
+// Pre-wraps all nested objects so React's Object.freeze won't break Proxy invariants
 function trackProps(obj) {
     const accessed = new Set();
+    const cache = new WeakMap();
 
-    function wrap(target, path) {
-        if (target === null || typeof target !== 'object') return target;
+    function wrap(source, prefix) {
+        if (source === null || typeof source !== 'object') return source;
+        if (cache.has(source)) return cache.get(source);
 
-        return new Proxy(target, {
+        const isArr = Array.isArray(source);
+        const copy = isArr ? [] : {};
+
+        for (const key of Object.keys(source)) {
+            const val = source[key];
+
+            if (val !== null && typeof val === 'object' && typeof val !== 'function') {
+                copy[key] = wrap(val, prefix ? prefix + '.' + key : key);
+            }
+            else {
+                copy[key] = val;
+            }
+        }
+
+        const proxy = new Proxy(copy, {
             get(t, prop, receiver) {
                 if (typeof prop === 'symbol') return Reflect.get(t, prop, receiver);
 
                 const val = Reflect.get(t, prop, receiver);
-                if (typeof val === 'function') return val;
+                if (typeof val === 'function') return val.bind(receiver);
 
-                const currentPath = path ? path + '.' + String(prop) : String(prop);
+                const currentPath = prefix ? prefix + '.' + String(prop) : String(prop);
                 accessed.add(currentPath);
 
-                if (val !== null && typeof val === 'object') {
-                    return wrap(val, currentPath);
-                }
-
                 return val;
             }
         });
+
+        cache.set(source, proxy);
+        return proxy;
     }
 
     return { proxy: wrap(obj, ''), accessed };

package/lib/Console/UpdateChecker.js

@@ -0,0 +1,118 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import Output from "./Output.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PKG_PATH = path.resolve(__dirname, "../../package.json");
+const REGISTRY_URL = "https://registry.npmjs.org/@nitronjs/framework/latest";
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT = 3000;
+
+const C = Output.COLORS;
+
+function getCachePath() {
+    const nitronDir = path.join(process.cwd(), ".nitron");
+
+    if (!fs.existsSync(nitronDir)) {
+        fs.mkdirSync(nitronDir, { recursive: true });
+    }
+
+    return path.join(nitronDir, "update-check.json");
+}
+
+function getCurrentVersion() {
+    const pkg = JSON.parse(fs.readFileSync(PKG_PATH, "utf-8"));
+    return pkg.version;
+}
+
+function compareVersions(current, latest) {
+    const a = current.split(".").map(Number);
+    const b = latest.split(".").map(Number);
+
+    for (let i = 0; i < 3; i++) {
+        if ((b[i] || 0) > (a[i] || 0)) return 1;
+        if ((b[i] || 0) < (a[i] || 0)) return -1;
+    }
+
+    return 0;
+}
+
+function readCache(cachePath) {
+    try {
+        if (fs.existsSync(cachePath)) {
+            return JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+        }
+    }
+    catch {}
+
+    return null;
+}
+
+function writeCache(cachePath, latestVersion) {
+    try {
+        fs.writeFileSync(cachePath, JSON.stringify({ lastCheck: Date.now(), latestVersion }));
+    }
+    catch {}
+}
+
+async function fetchLatestVersion() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT);
+
+    try {
+        const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+        const data = await res.json();
+        return data.version || null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+
+function printUpdateNotice(current, latest) {
+    const msg = `Update available: ${C.dim}${current}${C.reset} ${C.cyan}→${C.reset} ${C.green}${C.bold}${latest}${C.reset}`;
+    const cmd = `Run ${C.cyan}npm update @nitronjs/framework --save${C.reset} to update`;
+    const lines = [msg, cmd];
+    const maxLen = 52;
+
+    console.log();
+    console.log(`${C.yellow}╭${"─".repeat(maxLen)}╮${C.reset}`);
+
+    for (const line of lines) {
+        const rawLen = line.replace(/\x1b\[\d+m/g, "").length;
+        const pad = maxLen - 2 - rawLen;
+        console.log(`${C.yellow}│${C.reset} ${line}${" ".repeat(Math.max(0, pad))} ${C.yellow}│${C.reset}`);
+    }
+
+    console.log(`${C.yellow}╰${"─".repeat(maxLen)}╯${C.reset}`);
+    console.log();
+}
+
+export default async function checkForUpdates() {
+    try {
+        const cachePath = getCachePath();
+        const current = getCurrentVersion();
+        const cache = readCache(cachePath);
+
+        let latestVersion = cache?.latestVersion || null;
+        const needsCheck = !cache || (Date.now() - cache.lastCheck) > CHECK_INTERVAL;
+
+        if (needsCheck) {
+            const fetched = await fetchLatestVersion();
+
+            if (fetched) {
+                latestVersion = fetched;
+                writeCache(cachePath, fetched);
+            }
+        }
+
+        if (latestVersion && compareVersions(current, latestVersion) > 0) {
+            printUpdateNotice(current, latestVersion);
+        }
+    }
+    catch {}
+}

package/lib/View/View.js

@@ -40,27 +40,42 @@ function escapeHtml(str) {
 
 function trackProps(obj) {
     const accessed = new Set();
+    const cache = new WeakMap();
 
-    function wrap(target, prefix) {
-        if (target === null || typeof target !== "object") return target;
+    function wrap(source, prefix) {
+        if (source === null || typeof source !== "object") return source;
+        if (cache.has(source)) return cache.get(source);
 
-        return new Proxy(target, {
+        const isArr = Array.isArray(source);
+        const copy = isArr ? [] : {};
+
+        for (const key of Object.keys(source)) {
+            const val = source[key];
+
+            if (val !== null && typeof val === "object" && typeof val !== "function") {
+                copy[key] = wrap(val, prefix ? prefix + "." + key : key);
+            }
+            else {
+                copy[key] = val;
+            }
+        }
+
+        const proxy = new Proxy(copy, {
             get(t, prop, receiver) {
                 if (typeof prop === "symbol") return Reflect.get(t, prop, receiver);
 
                 const val = Reflect.get(t, prop, receiver);
-                if (typeof val === "function") return val;
+                if (typeof val === "function") return val.bind(receiver);
 
                 const currentPath = prefix ? prefix + "." + String(prop) : String(prop);
                 accessed.add(currentPath);
 
-                if (val !== null && typeof val === "object") {
-                    return wrap(val, currentPath);
-                }
-
                 return val;
             }
         });
+
+        cache.set(source, proxy);
+        return proxy;
     }
 
     return { proxy: wrap(obj, ""), accessed };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nitronjs/framework",
-	"version": "0.2.19",
+	"version": "0.2.20",
 	"description": "NitronJS is a modern and extensible Node.js MVC framework built on Fastify. It focuses on clean architecture, modular structure, and developer productivity, offering built-in routing, middleware, configuration management, CLI tooling, and native React integration for scalable full-stack applications.",
 	"bin": {
 		"njs": "./cli/njs.js"