@nitronjs/framework 0.2.19 → 0.2.21

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,34 +85,62 @@ 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;
 
-                const currentPath = path ? path + '.' + String(prop) : String(prop);
-                accessed.add(currentPath);
-
-                if (val !== null && typeof val === 'object') {
-                    return wrap(val, currentPath);
+                if (val !== undefined) {
+                    const currentPath = prefix ? prefix + '.' + String(prop) : String(prop);
+                    accessed.add(currentPath);
                 }
 
                 return val;
             }
         });
+
+        cache.set(source, proxy);
+        return proxy;
     }
 
     return { proxy: wrap(obj, ''), accessed };
 }
 
+function resolveExists(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length; i++) {
+        if (current == null || typeof current !== 'object') return false;
+        current = current[parts[i]];
+    }
+    return current !== undefined;
+}
+
 // Creates an island wrapper for client components (hydrated independently)
 function createIsland(Component, name) {
     function IslandBoundary(props) {
@@ -123,6 +151,14 @@ function createIsland(Component, name) {
         const id = React.useId();
         const tracker = trackProps(props);
 
+        if (Component.__propHints) {
+            for (const hint of Component.__propHints) {
+                if (resolveExists(props, hint)) {
+                    tracker.accessed.add(hint);
+                }
+            }
+        }
+
         const ctx = getContext();
         if (ctx) {
             ctx.props = ctx.props || {};

package/lib/Build/plugins.js

@@ -264,6 +264,13 @@ export function createMarkerPlugin(options, isDev) {
                     additionalCode += `try { Object.defineProperty(${exp.name}, ${symbolCode}, { value: true }); ${exp.name}.displayName = "${exp.name}"; } catch {}\n`;
                 }
 
+                const hints = extractPropHints(ast, exports.map(e => e.name));
+                if (hints.length > 0) {
+                    for (const exp of exports) {
+                        additionalCode += `try { ${exp.name}.__propHints = ${JSON.stringify(hints)}; } catch {}\n`;
+                    }
+                }
+
                 return { contents: source + additionalCode, loader: "tsx" };
             });
         }
@@ -321,4 +328,99 @@ function findExports(ast) {
     return exports;
 }
 
-export { findExports };
+/**
+ * Extracts prop access hints from a "use client" component's AST.
+ * Finds all property access patterns on destructured props, including
+ * those inside event handlers and other non-SSR code paths.
+ * @param {import("@babel/parser").ParseResult} ast - Parsed AST.
+ * @param {string[]} exportNames - Names of exported components.
+ * @returns {string[]} Array of prop access paths.
+ */
+function extractPropHints(ast, exportNames) {
+    const paramMap = new Map();
+
+    _traverse(ast, {
+        FunctionDeclaration(p) {
+            if (exportNames.includes(p.node.id?.name)) {
+                extractObjectParams(p.node.params[0], paramMap);
+            }
+        },
+        VariableDeclarator(p) {
+            if (exportNames.includes(p.node.id?.name)) {
+                const init = p.node.init;
+                if (init?.type === "ArrowFunctionExpression" || init?.type === "FunctionExpression") {
+                    extractObjectParams(init.params[0], paramMap);
+                }
+            }
+        }
+    });
+
+    if (paramMap.size === 0) return [];
+
+    const hints = new Set();
+
+    _traverse(ast, {
+        MemberExpression(p) {
+            collectPropHint(p, paramMap, hints);
+        },
+        OptionalMemberExpression(p) {
+            collectPropHint(p, paramMap, hints);
+        }
+    });
+
+    return [...hints].sort();
+}
+
+function extractObjectParams(param, map) {
+    if (!param || param.type !== "ObjectPattern") return;
+
+    for (const prop of param.properties) {
+        if (prop.type === "ObjectProperty") {
+            const propName = prop.key.name || prop.key.value;
+            const localName = prop.value.type === "Identifier"
+                ? prop.value.name
+                : prop.value.type === "AssignmentPattern" && prop.value.left?.type === "Identifier"
+                    ? prop.value.left.name
+                    : null;
+
+            if (propName && localName) {
+                map.set(localName, propName);
+            }
+        }
+        else if (prop.type === "RestElement" && prop.argument?.type === "Identifier") {
+            map.set(prop.argument.name, prop.argument.name);
+        }
+    }
+}
+
+function collectPropHint(path, paramMap, hints) {
+    const parent = path.parent;
+
+    if ((parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") && parent.object === path.node) {
+        return;
+    }
+
+    const chain = [];
+    let current = path.node;
+
+    while (current.type === "MemberExpression" || current.type === "OptionalMemberExpression") {
+        if (current.computed) return;
+        if (current.property?.type !== "Identifier") return;
+        chain.unshift(current.property.name);
+        current = current.object;
+    }
+
+    if (current.type !== "Identifier") return;
+
+    const rootProp = paramMap.get(current.name);
+    if (!rootProp) return;
+
+    if (parent.type === "CallExpression" && parent.callee === path.node && chain.length > 0) {
+        chain.pop();
+    }
+
+    const fullPath = chain.length > 0 ? rootProp + "." + chain.join(".") : rootProp;
+    hints.add(fullPath);
+}
+
+export { findExports, extractPropHints };

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/Database/Model.js

@@ -59,6 +59,16 @@ class Model {
                 target._attributes[prop] = value;
 
                 return true;
+            },
+            ownKeys: (target) => {
+                return [...Object.keys(target._attributes), ...Object.getOwnPropertyNames(target)];
+            },
+            getOwnPropertyDescriptor: (target, prop) => {
+                if (prop in target._attributes) {
+                    return { configurable: true, enumerable: true, value: target._attributes[prop] };
+                }
+
+                return Object.getOwnPropertyDescriptor(target, prop);
             }
         });
     }

package/lib/Route/Router.js

@@ -151,7 +151,7 @@ class Router {
             }
 
             // Resolve middleware names to handlers
-            const middlewareHandlers = route.middlewares.map(middleware => {
+            route.resolvedMiddlewares = route.middlewares.map(middleware => {
                 const [name, param] = middleware.split(":");
 
                 if (!Kernel.routeMiddlewares[name]) {
@@ -164,13 +164,13 @@ class Router {
             });
 
             // Wrap controller handler for HMR
-            const handler = hotReload.wrap(route.handler);
+            route.resolvedHandler = hotReload.wrap(route.handler);
 
             server.route({
                 method: route.method,
                 url: route.url,
-                preHandler: middlewareHandlers,
-                handler
+                preHandler: route.resolvedMiddlewares,
+                handler: route.resolvedHandler
             });
         }
     }

package/lib/View/View.js

@@ -40,32 +40,61 @@ 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;
 
-                const currentPath = prefix ? prefix + "." + String(prop) : String(prop);
-                accessed.add(currentPath);
-
-                if (val !== null && typeof val === "object") {
-                    return wrap(val, currentPath);
+                if (val !== undefined) {
+                    const currentPath = prefix ? prefix + "." + String(prop) : String(prop);
+                    accessed.add(currentPath);
                 }
 
                 return val;
             }
         });
+
+        cache.set(source, proxy);
+        return proxy;
     }
 
     return { proxy: wrap(obj, ""), accessed };
 }
 
+function resolveExists(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+
+    for (let i = 0; i < parts.length; i++) {
+        if (current == null || typeof current !== "object") return false;
+        current = current[parts[i]];
+    }
+
+    return current !== undefined;
+}
+
 /**
  * React SSR view renderer with streaming support.
  * Handles component rendering, asset injection, and client hydration.
@@ -183,7 +212,7 @@ class View {
                 return { status: 404, error: "Route not found" };
             }
 
-            const { handler, params, route } = routeMatch;
+            const { params, route } = routeMatch;
 
             let viewName = null;
             let viewParams = {};
@@ -207,7 +236,7 @@ class View {
                 session: originalReq.session
             };
 
-            for (const mw of route.middlewares || []) {
+            for (const mw of route.resolvedMiddlewares || []) {
                 if (redirectTo || handled) break;
                 try {
                     await mw(mockReq, mockRes);
@@ -222,7 +251,7 @@ class View {
             if (handled) return { handled: true };
             if (redirectTo) return this.#validateRedirect(redirectTo, originalReq.headers.host);
 
-            await handler(mockReq, mockRes);
+            await (route.resolvedHandler || route.handler)(mockReq, mockRes);
 
             if (handled) return { handled: true };
             if (redirectTo) return this.#validateRedirect(redirectTo, originalReq.headers.host);
@@ -368,6 +397,14 @@ class View {
                 if (Component[MARK]) {
                     const tracker = trackProps(params);
 
+                    if (Component.__propHints) {
+                        for (const hint of Component.__propHints) {
+                            if (resolveExists(params, hint)) {
+                                tracker.accessed.add(hint);
+                            }
+                        }
+                    }
+
                     ctx.props[":R0:"] = params;
                     ctx.trackers = ctx.trackers || {};
                     ctx.trackers[":R0:"] = tracker.accessed;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nitronjs/framework",
-	"version": "0.2.19",
+	"version": "0.2.21",
 	"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"