@nitronjs/framework 0.2.20 → 0.2.21

package/lib/Build/jsxRuntime.js

@@ -113,10 +113,12 @@ function trackProps(obj) {
                 if (typeof prop === 'symbol') return Reflect.get(t, prop, receiver);
 
                 const val = Reflect.get(t, prop, receiver);
-                if (typeof val === 'function') return val.bind(receiver);
+                if (typeof val === 'function') return val;
 
-                const currentPath = prefix ? prefix + '.' + String(prop) : String(prop);
-                accessed.add(currentPath);
+                if (val !== undefined) {
+                    const currentPath = prefix ? prefix + '.' + String(prop) : String(prop);
+                    accessed.add(currentPath);
+                }
 
                 return val;
             }
@@ -129,6 +131,16 @@ function trackProps(obj) {
     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) {
@@ -139,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/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

@@ -65,10 +65,12 @@ function trackProps(obj) {
                 if (typeof prop === "symbol") return Reflect.get(t, prop, receiver);
 
                 const val = Reflect.get(t, prop, receiver);
-                if (typeof val === "function") return val.bind(receiver);
+                if (typeof val === "function") return val;
 
-                const currentPath = prefix ? prefix + "." + String(prop) : String(prop);
-                accessed.add(currentPath);
+                if (val !== undefined) {
+                    const currentPath = prefix ? prefix + "." + String(prop) : String(prop);
+                    accessed.add(currentPath);
+                }
 
                 return val;
             }
@@ -81,6 +83,18 @@ function trackProps(obj) {
     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.
@@ -198,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 = {};
@@ -222,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);
@@ -237,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);
@@ -383,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.20",
+	"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"