@nitronjs/framework 0.2.13 → 0.2.14

package/lib/Auth/Auth.js

@@ -82,6 +82,7 @@ class Auth {
         const guard = guardName || authConfig.defaults.guard;
 
         req.session.set(`auth_${guard}`, null);
+        req.session.regenerate();
     }
 
     /**

package/lib/Build/Manager.js

@@ -116,8 +116,11 @@ class Builder {
             };
         } catch (error) {
             this.#cleanupTemp();
-            if (!silent) console.log(`\n${COLORS.red}✖ Build failed: ${error.message}${COLORS.reset}\n`);
-            if (this.#isDev && !silent) console.error(error);
+
+            if (!silent) {
+                console.log(this.#formatBuildError(error));
+            }
+
             return { success: false, error: error.message };
         }
     }
@@ -580,6 +583,63 @@ class Builder {
         }
     }
 
+    #formatBuildError(error) {
+        const R = COLORS.red, Y = COLORS.yellow, D = COLORS.dim, C = COLORS.reset;
+
+        // FileAnalyzer errors already have formatted messages
+        if (error.message?.includes("✖")) {
+            return `\n${error.message}\n`;
+        }
+
+        // esbuild errors — extract detailed info from .errors array
+        if (error.errors?.length > 0) {
+            let output = `\n${R}✖ Build failed${C}\n`;
+
+            for (const err of error.errors.slice(0, 5)) {
+                const loc = err.location;
+                output += `\n  ${R}${err.text}${C}\n`;
+
+                if (loc) {
+                    const file = loc.file ? path.relative(Paths.project, loc.file) : "unknown";
+                    output += `  ${D}at${C} ${Y}${file}:${loc.line}:${loc.column}${C}\n`;
+
+                    if (loc.lineText) {
+                        output += `  ${D}${loc.lineText.trim()}${C}\n`;
+                    }
+                }
+
+                if (err.notes?.length > 0) {
+                    for (const note of err.notes) {
+                        output += `  ${D}→ ${note.text}${C}\n`;
+                    }
+                }
+            }
+
+            if (error.errors.length > 5) {
+                output += `\n  ${D}... and ${error.errors.length - 5} more errors${C}\n`;
+            }
+
+            return output;
+        }
+
+        // Generic errors — provide hint based on common patterns
+        const msg = error.message || "Unknown error";
+        let output = `\n${R}✖ Build failed${C}\n\n  ${msg}\n`;
+
+        if (msg.includes("ENOENT")) {
+            output += `\n  ${Y}Hint:${C} A file or directory was not found. Check your import paths.\n`;
+        }
+        else if (msg.includes("Duplicate")) {
+            output += `\n  ${Y}Hint:${C} Two views resolve to the same route. Rename one of them.\n`;
+        }
+        else if (msg.includes("Cannot find module")) {
+            const match = msg.match(/Cannot find module ['"]([^'"]+)['"]/);
+            if (match) output += `\n  ${Y}Hint:${C} Module "${match[1]}" is not installed. Run npm install.\n`;
+        }
+
+        return output;
+    }
+
     #cleanupTemp() {
         const projectDir = path.normalize(Paths.project) + path.sep;
         const normalizedTemp = path.normalize(this.#paths.nitronTemp);

package/lib/Build/jsxRuntime.js

@@ -35,7 +35,7 @@ globalThis.csrf = () => getContext()?.csrf || '';
 
 globalThis.request = () => {
     const ctx = getContext();
-    return ctx?.request || { params: {}, query: {}, url: '', method: 'GET', headers: {} };
+    return ctx?.request || { path: '', method: 'GET', query: {}, params: {}, headers: {}, cookies: {}, ip: '', isAjax: false, session: null, auth: null };
 };
 
 const DepthContext = React.createContext(false);

package/lib/Date/DateTime.js

@@ -21,7 +21,14 @@ class DateTime {
     static #format(date, formatString) {
         const lang = locale[Config.get('app.locale', 'en')] || locale.en;
         const pad = (n) => String(n).padStart(2, '0');
-        
+
+        // Replace multi-character tokens first to avoid per-character replacement
+        let result = formatString;
+        result = result.replace(/MMMM/g, '\x01MONTH\x01');
+        result = result.replace(/MMM/g, '\x01MONTHSHORT\x01');
+        result = result.replace(/DDDD/g, '\x01DAY\x01');
+        result = result.replace(/DDD/g, '\x01DAYSHORT\x01');
+
         const map = {
             'Y': date.getFullYear(),
             'y': String(date.getFullYear()).slice(-2),
@@ -37,8 +44,16 @@ class DateTime {
             'M': lang.months[date.getMonth()],
             'F': lang.monthsShort[date.getMonth()]
         };
-        
-        return formatString.replace(/[YynmdjHislDMF]/g, match => map[match]);
+
+        result = result.replace(/[YynmdjHislDMF]/g, match => map[match]);
+
+        // Restore multi-character tokens
+        result = result.replace(/\x01MONTH\x01/g, lang.months[date.getMonth()]);
+        result = result.replace(/\x01MONTHSHORT\x01/g, lang.monthsShort[date.getMonth()]);
+        result = result.replace(/\x01DAY\x01/g, lang.days[date.getDay()]);
+        result = result.replace(/\x01DAYSHORT\x01/g, lang.daysShort[date.getDay()]);
+
+        return result;
     }
     
     /**

package/lib/Http/Server.js

@@ -107,10 +107,47 @@ class Server {
 
         this.#server.register(fastifyStatic, {
             root: Paths.public,
-            decorateReply: false,
-            index: false
+            decorateReply: true,
+            index: false,
+            wildcard: false
         });
 
+        // Register explicit routes for each public subdirectory.
+        // Routes like /storage/* have a static prefix and take priority over
+        // parametric routes (/:slug), preventing catch-all routes from
+        // intercepting static file requests.
+        if (fs.existsSync(Paths.public)) {
+            for (const entry of fs.readdirSync(Paths.public)) {
+                const fullPath = path.resolve(Paths.public, entry);
+
+                try {
+                    if (!fs.statSync(fullPath).isDirectory()) continue;
+                }
+                catch {
+                    continue;
+                }
+
+                this.#server.route({
+                    method: ["GET", "HEAD"],
+                    url: `/${entry}/*`,
+                    handler(req, reply) {
+                        return reply.sendFile(req.params["*"], fullPath);
+                    }
+                });
+            }
+
+            // Fallback wildcard for root-level files (favicon.ico, robots.txt, etc.)
+            // Less specific than /:slug so it loses when parametric routes exist,
+            // but keeps backward compatibility for projects without catch-all routes.
+            this.#server.route({
+                method: ["GET", "HEAD"],
+                url: "/*",
+                handler(req, reply) {
+                    return reply.sendFile(req.params["*"]);
+                }
+            });
+        }
+
         this.#server.register(fastifyCookie, {
             secret: process.env.APP_KEY,
             hook: "onRequest"

package/lib/Session/File.js

@@ -27,7 +27,7 @@ class FileStore {
         }
 
         try {
-            const content = await fs.readFile(this.#filePath(sessionId), "utf8");
+            const content = await this.#retryOnLock(() => fs.readFile(this.#filePath(sessionId), "utf8"));
 
             if (!content?.trim()) {
                 await this.delete(sessionId);
@@ -48,6 +48,8 @@ class FileStore {
                 return null;
             }
 
+            console.error("[Session File] Read error:", err.message);
+
             return null;
         }
     }
@@ -67,10 +69,19 @@ class FileStore {
         const json = Environment.isDev ? JSON.stringify(data, null, 2) : JSON.stringify(data);
 
         try {
-            await fs.writeFile(tempPath, json, "utf8");
+            await this.#retryOnLock(() => fs.writeFile(tempPath, json, "utf8"));
             await this.#atomicRename(tempPath, filePath);
         }
-        catch {
+        catch (err) {
+            // Atomic rename failed — write directly as fallback to prevent session loss
+            try {
+                await this.#retryOnLock(() => fs.writeFile(filePath, json, "utf8"));
+            }
+            catch (writeErr) {
+                console.error("[Session File] Write fallback failed:", writeErr.message);
+                throw writeErr;
+            }
+
             await fs.unlink(tempPath).catch(() => {});
         }
     }
@@ -85,12 +96,12 @@ class FileStore {
         }
 
         try {
-            await fs.unlink(this.#filePath(sessionId));
+            await this.#retryOnLock(() => fs.unlink(this.#filePath(sessionId)));
         }
         catch (err) {
-            if (err.code !== "ENOENT") {
-                console.error("[Session File] Delete error:", err.message);
-            }
+            if (err.code === "ENOENT") return;
+
+            console.error("[Session File] Delete error:", err.message);
         }
     }
 
@@ -118,16 +129,24 @@ class FileStore {
                     const lastActivity = data.lastActivity || data.createdAt;
 
                     if (now - lastActivity > lifetime) {
-                        await fs.unlink(filePath);
+                        await fs.unlink(filePath).catch(() => {});
                         deleted++;
                     }
                 }
                 catch {
+                    // Corrupted or unreadable — try to clean up, skip if locked
                     await fs.unlink(filePath).catch(() => {});
                     deleted++;
                 }
             }
 
+            // Clean leftover temp files
+            for (const file of files) {
+                if (file.endsWith(".tmp")) {
+                    await fs.unlink(path.join(this.#storagePath, file)).catch(() => {});
+                }
+            }
+
             return deleted;
         }
         catch (err) {
@@ -198,15 +217,41 @@ class FileStore {
             await fs.rename(from, to);
         }
         catch (err) {
-            if (err.code === "EPERM" || err.code === "EEXIST") {
-                await fs.unlink(to).catch(() => {});
-                await fs.rename(from, to);
+            if (err.code === "EPERM" || err.code === "EBUSY" || err.code === "EEXIST") {
+                await this.#retryOnLock(() => fs.copyFile(from, to));
+                await fs.unlink(from).catch(() => {});
             }
             else {
                 throw err;
             }
         }
     }
+
+    /**
+     * Retries a file operation with exponential backoff on Windows lock errors.
+     * @private
+     * @param {Function} fn - Async function to retry
+     * @param {number} maxRetries - Maximum retry attempts (default: 4)
+     * @returns {Promise<*>}
+     */
+    async #retryOnLock(fn, maxRetries = 4) {
+        let delay = 50;
+
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (err) {
+                if ((err.code === "EBUSY" || err.code === "EPERM") && attempt < maxRetries) {
+                    await new Promise(r => setTimeout(r, delay));
+                    delay *= 2;
+                    continue;
+                }
+
+                throw err;
+            }
+        }
+    }
 }
 
 export default FileStore;

package/lib/Session/Manager.js

@@ -179,23 +179,21 @@ class SessionManager {
         });
 
         server.addHook("onSend", async (request, response, payload) => {
-            if (request.session?.shouldRegenerate()) {
-                response.setCookie(manager.cookieName, request.session.id, manager.cookieConfig);
-            }
+            if (!request.session) return payload;
 
-            return payload;
-        });
+            try {
+                await manager.persist(request.session);
 
-        server.addHook("onResponse", async (request, response) => {
-            if (!request.session || response.statusCode >= 400) {
-                return;
+                if (request.session.shouldRegenerate()) {
+                    response.setCookie(manager.cookieName, request.session.id, manager.cookieConfig);
+                    await manager.deleteOld(request.session.getOldId());
+                }
             }
-
-            if (request.session.shouldRegenerate()) {
-                await manager.deleteOld(request.session.getOldId());
+            catch (err) {
+                console.error("[Session] Persist error:", err.message);
             }
 
-            await manager.persist(request.session);
+            return payload;
         });
 
         manager.#startGC();

package/lib/Session/Session.js

@@ -17,6 +17,10 @@ class Session {
         this.#data = sessionData.data || {};
         this.#createdAt = sessionData.createdAt || Date.now();
         this.#lastActivity = sessionData.lastActivity || null;
+
+        // Age flash data: previous request's flash becomes readable, then expires.
+        this.#data._previousFlash = this.#data._flash || {};
+        this.#data._flash = {};
     }
 
     get id() {
@@ -50,11 +54,14 @@ class Session {
     }
 
     /**
-     * Gets all session data (copy).
+     * Gets all session data for persistence.
+     * Excludes aged flash data that should not survive another request.
      * @returns {Object}
      */
     all() {
-        return { ...this.#data };
+        const { _previousFlash, ...rest } = this.#data;
+
+        return rest;
     }
 
     /**
@@ -100,32 +107,21 @@ class Session {
     }
 
     /**
-     * Stores a flash message (available only for next request).
+     * Stores a flash message (available only for the next request).
      * @param {string} key
      * @param {*} value
      */
     flash(key, value) {
-        if (!this.#data._flash) {
-            this.#data._flash = {};
-        }
-
         this.#data._flash[key] = value;
     }
 
     /**
-     * Gets and removes a flash message.
+     * Gets a flash message from the previous request.
      * @param {string} key
      * @returns {*}
      */
     getFlash(key) {
-        if (!this.#data._flash?.[key]) {
-            return undefined;
-        }
-
-        const value = this.#data._flash[key];
-        delete this.#data._flash[key];
-
-        return value;
+        return this.#data._previousFlash?.[key];
     }
 
     /**

package/lib/View/View.js

@@ -291,94 +291,102 @@ class View {
             throw new Error(`View not found: ${name}`);
         }
 
-        const mod = await import(pathToFileURL(viewPath).href + `?t=${Date.now()}`);
-        if (!mod.default) {
-            throw new Error("View must have a default export");
-        }
-
-        const layoutChain = entry?.layouts || [];
-        const layoutModules = [];
-
-        for (const layoutName of layoutChain) {
-            const layoutPath = path.join(baseDir, layoutName + ".js");
-            if (existsSync(layoutPath)) {
-                const layoutMod = await import(pathToFileURL(layoutPath).href + `?t=${Date.now()}`);
-                if (layoutMod.default) {
-                    layoutModules.push(layoutMod);
-                }
-            }
-        }
-
         const nonce = randomBytes(16).toString("hex");
         const ctx = {
             nonce,
             csrf,
             props: {},
             request: fastifyRequest ? {
-                params: fastifyRequest.params || {},
-                query: fastifyRequest.query || {},
-                url: fastifyRequest.url || '',
+                path: (fastifyRequest.url || '').split('?')[0],
                 method: fastifyRequest.method || 'GET',
-                headers: fastifyRequest.headers || {}
+                query: fastifyRequest.query || {},
+                params: fastifyRequest.params || {},
+                headers: fastifyRequest.headers || {},
+                cookies: fastifyRequest.cookies || {},
+                ip: fastifyRequest.ip || '',
+                isAjax: fastifyRequest.headers?.['x-requested-with'] === 'XMLHttpRequest',
+                session: fastifyRequest.session || null,
+                auth: fastifyRequest.auth || null,
             } : null
         };
-        let html = "";
-        let collectedProps = {};
 
-        try {
-            const Component = mod.default;
-            let element;
-
-            if (Component[MARK]) {
-                ctx.props[":R0:"] = this.#sanitizeProps(params);
-                element = React.createElement(
-                    "div",
-                    {
-                        "data-cid": ":R0:",
-                        "data-island": Component.displayName || Component.name || "Anonymous"
-                    },
-                    React.createElement(Component, params)
-                );
-            } else {
-                element = React.createElement(Component, params);
+        return Context.run(ctx, async () => {
+            const mod = await import(pathToFileURL(viewPath).href + `?t=${Date.now()}`);
+            if (!mod.default) {
+                throw new Error("View must have a default export");
             }
 
-            if (layoutModules.length > 0) {
-                element = React.createElement("div", { "data-nitron-slot": "page" }, element);
-            }
+            const layoutChain = entry?.layouts || [];
+            const layoutModules = [];
 
-            for (let i = layoutModules.length - 1; i >= 0; i--) {
-                const LayoutComponent = layoutModules[i].default;
-                element = React.createElement(LayoutComponent, { children: element });
+            for (const layoutName of layoutChain) {
+                const layoutPath = path.join(baseDir, layoutName + ".js");
+                if (existsSync(layoutPath)) {
+                    const layoutMod = await import(pathToFileURL(layoutPath).href + `?t=${Date.now()}`);
+                    if (layoutMod.default) {
+                        layoutModules.push(layoutMod);
+                    }
+                }
             }
 
-            html = await Context.run(ctx, () => this.#renderToHtml(element));
-            collectedProps = ctx.props;
-        } catch (error) {
-            const componentName = mod.default?.displayName || mod.default?.name || "Unknown";
-            const errorDetails = this.#parseReactError(error);
-
-            Log.error("Render Error", {
-                view: name,
-                component: componentName,
-                error: error.message,
-                cause: errorDetails.cause,
-                location: errorDetails.location,
-                stack: error.stack
-            });
+            let html = "";
+            let collectedProps = {};
 
-            error.statusCode = error.statusCode || 500;
-            throw error;
-        }
+            try {
+                const Component = mod.default;
+                let element;
+
+                if (Component[MARK]) {
+                    ctx.props[":R0:"] = this.#sanitizeProps(params);
+                    element = React.createElement(
+                        "div",
+                        {
+                            "data-cid": ":R0:",
+                            "data-island": Component.displayName || Component.name || "Anonymous"
+                        },
+                        React.createElement(Component, params)
+                    );
+                } else {
+                    element = React.createElement(Component, params);
+                }
 
-        const mergedMeta = this.#mergeMeta(layoutModules, mod.Meta, params);
+                if (layoutModules.length > 0) {
+                    element = React.createElement("div", { "data-nitron-slot": "page" }, element);
+                }
 
-        return {
-            html,
-            nonce,
-            meta: mergedMeta,
-            props: collectedProps
-        };
+                for (let i = layoutModules.length - 1; i >= 0; i--) {
+                    const LayoutComponent = layoutModules[i].default;
+                    element = React.createElement(LayoutComponent, { children: element });
+                }
+
+                html = await this.#renderToHtml(element);
+                collectedProps = ctx.props;
+            } catch (error) {
+                const componentName = mod.default?.displayName || mod.default?.name || "Unknown";
+                const errorDetails = this.#parseReactError(error);
+
+                Log.error("Render Error", {
+                    view: name,
+                    component: componentName,
+                    error: error.message,
+                    cause: errorDetails.cause,
+                    location: errorDetails.location,
+                    stack: error.stack
+                });
+
+                error.statusCode = error.statusCode || 500;
+                throw error;
+            }
+
+            const mergedMeta = this.#mergeMeta(layoutModules, mod.Meta, params);
+
+            return {
+                html,
+                nonce,
+                meta: mergedMeta,
+                props: collectedProps
+            };
+        });
     }
 
     static #mergeMeta(layoutModules, viewMeta, params = {}) {
@@ -715,7 +723,7 @@ class View {
         const devIndicator = this.#isDev ? this.#generateDevIndicator(nonceAttr) : "";
 
         return `<!DOCTYPE html>
-<html lang="en">
+<html lang="${meta?.lang || "en"}">
 <head>
 ${this.#generateHead(meta, css)}
 </head>
@@ -738,6 +746,14 @@ ${vendorScript}${hmrScript}${hydrateScript}${spaScript}${devIndicator}
             parts.push(`<meta name="description" content="${escapeHtml(meta.description)}">`);
         }
 
+        if (meta.keywords) {
+            parts.push(`<meta name="keywords" content="${escapeHtml(meta.keywords)}">`);
+        }
+
+        if (meta.favicon) {
+            parts.push(`<link rel="icon" href="${escapeHtml(meta.favicon)}">`);
+        }
+
         for (const href of css) {
             parts.push(`<link rel="stylesheet" href="${escapeHtml(href)}">`);
         }

package/lib/index.d.ts

@@ -224,7 +224,7 @@ export class Lang {
 export class DateTime {
     static toSQL(timestamp?: number | null): string;
     static getTime(sqlDateTime?: string | null): number;
-    static getDate(timestamp?: number | null, format?: string): string;
+    static getDate(timestamp?: string | number | null, format?: string): string;
     static addDays(days: number): string;
     static addHours(hours: number): string;
     static subDays(days: number): string;
@@ -503,7 +503,6 @@ declare global {
         method: string;
         query: Record<string, any>;
         params: Record<string, any>;
-        body: Record<string, any>;
         headers: Record<string, string>;
         cookies: Record<string, string>;
         ip: string;
@@ -515,5 +514,13 @@ declare global {
             forget(key: string): void;
             flash(key: string, value: any): void;
         };
+        auth: {
+            guard(name?: string): {
+                user<T = any>(): Promise<T | null>;
+                check(): boolean;
+            };
+            user<T = any>(): Promise<T | null>;
+            check(): boolean;
+        };
     };
 }

package/package.json

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

package/skeleton/tsconfig.json

@@ -12,6 +12,7 @@
         "forceConsistentCasingInFileNames": true,
         "noEmit": true,
         "baseUrl": ".",
+        "allowJs": true,
         "paths": {
             "@/*": ["./*"],
             "@css/*": ["./resources/css/*"],