@nitronjs/framework 0.2.26 → 0.2.27

package/lib/Build/FileAnalyzer.js

@@ -63,7 +63,7 @@ class FileAnalyzer {
 
         this.#validateGraph(graph, entries, importedBy);
 
-        return { entries, layouts, meta: graph };
+        return { entries, layouts, meta: graph, importedBy };
     }
 
     #findTsxFiles(dir, result = []) {

package/lib/Build/Manager.js

@@ -309,7 +309,7 @@ class Builder {
             return { entries: [], layouts: [], meta: new Map(), srcDir, namespace, changedFiles: [] };
         }
 
-        const { entries, layouts, meta } = this.#analyzer.discoverEntries(srcDir);
+        const { entries, layouts, meta, importedBy } = this.#analyzer.discoverEntries(srcDir);
 
         if (!entries.length && !layouts.length) {
             return { entries: [], layouts: [], meta: new Map(), srcDir, namespace, changedFiles: [] };
@@ -318,19 +318,36 @@ class Builder {
         this.#addToManifest(entries, layouts, meta, srcDir, namespace);
 
         const allFiles = [...entries, ...layouts];
-        const changedFiles = [];
+        const entryLayoutSet = new Set(allFiles);
+        const changedSources = new Set();
 
-        for (const file of allFiles) {
+        for (const file of meta.keys()) {
             const content = await fs.promises.readFile(file, "utf8");
             const hash = crypto.createHash("md5").update(content).digest("hex");
             const cachedHash = this.#cache.viewHashes.get(file);
 
             if (cachedHash !== hash) {
                 this.#cache.viewHashes.set(file, hash);
-                changedFiles.push(file);
+                changedSources.add(file);
             }
         }
 
+        const filesToBuild = new Set();
+
+        for (const file of changedSources) {
+            if (entryLayoutSet.has(file)) {
+                filesToBuild.add(file);
+            }
+
+            for (const dep of this.#getTransitiveDependents(file, importedBy)) {
+                if (entryLayoutSet.has(dep)) {
+                    filesToBuild.add(dep);
+                }
+            }
+        }
+
+        const changedFiles = [...filesToBuild];
+
         if (changedFiles.length) {
             this.#cache.viewsChanged = true;
             await this.#runEsbuild(changedFiles, outDir, { meta, outbase: srcDir });
@@ -444,6 +461,25 @@ class Builder {
         this.#stats.islands = hydrationFiles.length;
     }
 
+    #getTransitiveDependents(file, importedBy) {
+        const result = new Set();
+        const queue = [file];
+
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const dependents = importedBy.get(current) || [];
+
+            for (const dep of dependents) {
+                if (!result.has(dep)) {
+                    result.add(dep);
+                    queue.push(dep);
+                }
+            }
+        }
+
+        return result;
+    }
+
     async #buildCss() {
         this.#stats.css = await this.#cssBuilder.build(this.#cache.viewsChanged);
     }

package/lib/Http/Server.js

@@ -283,7 +283,12 @@ class Server {
             console.log("\x1b[32m✓ Server stopped gracefully\x1b[0m");
             
             try {
-                (await SessionManager.getInstance()).stopGC();
+                const sessionManager = await SessionManager.getInstance();
+
+                await Promise.race([
+                    sessionManager.close(),
+                    new Promise(resolve => setTimeout(resolve, 1000))
+                ]);
                 await Promise.race([
                     DB.close(),
                     new Promise(resolve => setTimeout(resolve, 1000))

package/lib/Session/Manager.js

@@ -2,6 +2,7 @@ import crypto from "crypto";
 import Config from "../Core/Config.js";
 import Memory from "./Memory.js";
 import File from "./File.js";
+import RedisStore from "./Redis.js";
 import Session from "./Session.js";
 
 /**
@@ -44,7 +45,26 @@ class SessionManager {
         this.#config = Config.all("session");
         this.#config.cookie.signed = true;
 
-        this.#store = this.#config.driver === "file" ? new File() : new Memory();
+        switch (this.#config.driver) {
+            case "file":
+                this.#store = new File();
+                break;
+
+            case "memory":
+                this.#store = new Memory();
+                break;
+
+            case "redis":
+                this.#store = new RedisStore(this.#config.lifetime);
+                break;
+
+            case "none":
+                this.#store = null;
+                return;
+
+            default:
+                throw new Error(`[Session] Unknown driver: "${this.#config.driver}"`);
+        }
 
         if (this.#store.ready) {
             await this.#store.ready;
@@ -182,6 +202,17 @@ class SessionManager {
         }
     }
 
+    /**
+     * Closes the session store connection.
+     */
+    async close() {
+        this.stopGC();
+
+        if (this.#store && typeof this.#store.close === "function") {
+            await this.#store.close();
+        }
+    }
+
     /**
      * Sets up session middleware for Fastify.
      * @param {import("fastify").FastifyInstance} server
@@ -189,9 +220,19 @@ class SessionManager {
     static async setup(server) {
         const manager = await SessionManager.getInstance();
 
+        if (!manager.#store) {
+            return;
+        }
+
         server.decorateRequest("session", null);
 
         server.addHook("preHandler", async (request, response) => {
+            const lastSegment = request.url.split("/").pop().split("?")[0];
+
+            if (lastSegment.includes(".")) {
+                return;
+            }
+
             request.session = await manager.load(request, response);
         });
 

package/lib/Session/Redis.js

@@ -0,0 +1,117 @@
+import { createClient } from "redis";
+import Log from "../Logging/Log.js";
+
+/**
+ * Redis-based session storage.
+ * Stores sessions as JSON strings with automatic TTL expiry.
+ */
+class RedisStore {
+    #client;
+    #prefix;
+    #ttl;
+    ready;
+
+    constructor(lifetime) {
+        this.#prefix = (process.env.APP_NAME || "app") + ":session:";
+        this.#ttl = Math.ceil(lifetime / 1000);
+        this.ready = this.#connect();
+    }
+
+    /**
+     * Gets session data by ID.
+     * @param {string} id
+     * @returns {Promise<Object|null>}
+     */
+    async get(id) {
+        const data = await this.#client.get(this.#prefix + id);
+
+        if (!data) {
+            return null;
+        }
+
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            await this.delete(id);
+
+            return null;
+        }
+    }
+
+    /**
+     * Stores session data with automatic TTL.
+     * @param {string} id
+     * @param {Object} value
+     */
+    async set(id, value) {
+        await this.#client.set(this.#prefix + id, JSON.stringify(value), {
+            EX: this.#ttl
+        });
+    }
+
+    /**
+     * Deletes a session.
+     * @param {string} id
+     */
+    async delete(id) {
+        await this.#client.del(this.#prefix + id);
+    }
+
+    /**
+     * Garbage collection — no-op for Redis.
+     * Redis handles expiry automatically via TTL.
+     * @returns {Promise<number>}
+     */
+    async gc() {
+        return 0;
+    }
+
+    /**
+     * Closes the Redis connection gracefully.
+     */
+    async close() {
+        if (this.#client) {
+            await this.#client.quit();
+            this.#client = null;
+        }
+    }
+
+    /** @private */
+    async #connect() {
+        const host = process.env.REDIS_HOST || "127.0.0.1";
+        const port = Number(process.env.REDIS_PORT) || 6379;
+        const password = process.env.REDIS_PASSWORD || undefined;
+
+        this.#client = createClient({
+            socket: {
+                host,
+                port,
+                reconnectStrategy: (retries) => {
+                    if (retries > 10) {
+                        console.error("\x1b[31m✕ [Session Redis] Connection lost after 10 retries. Shutting down.\x1b[0m");
+                        Log.fatal("Redis connection lost permanently", { retries });
+                        process.emit("SIGTERM");
+
+                        return false;
+                    }
+
+                    return Math.min(retries * 100, 5000);
+                }
+            },
+            password
+        });
+
+        this.#client.on("error", (err) => {
+            console.error(`\x1b[31m✕ [Session Redis] ${err.message}\x1b[0m`);
+        });
+
+        this.#client.on("ready", () => {
+            console.log("\x1b[32m✓ [Session Redis] Connected\x1b[0m");
+        });
+
+        await this.#client.connect();
+    }
+}
+
+export default RedisStore;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nitronjs/framework",
-	"version": "0.2.26",
+	"version": "0.2.27",
 	"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"
@@ -36,6 +36,7 @@
 		"react": "^19.2.3",
 		"react-dom": "^19.2.3",
 		"react-refresh": "^0.18.0",
+		"redis": "^5.6.0",
 		"socket.io": "^4.8.1",
 		"tailwindcss": "^4.1.18",
 		"typescript": "^5.9.3"

package/skeleton/config/session.js

@@ -1,6 +1,7 @@
 const SESSION_LIFETIME = 1000 * 60 * 60 * 2;
 
 export default {
+    // Driver: none | file | memory | redis
     driver: "file",
     lifetime: SESSION_LIFETIME,
     cookieName: "session",