@nitronjs/framework 0.2.12 → 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/FileAnalyzer.js

@@ -239,7 +239,7 @@ class FileAnalyzer {
         if (declaration?.type === "VariableDeclaration") {
             for (const decl of declaration.declarations) {
                 if (decl.id.type === "Identifier") {
-                    if (decl.id.name === "layout" &&
+                    if (decl.id.name === "Layout" &&
                         decl.init?.type === "BooleanLiteral" &&
                         decl.init.value === false) {
                         meta.layoutDisabled = true;

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/Build/plugins.js

@@ -162,7 +162,8 @@ export function createServerModuleBlockerPlugin() {
 
 /**
  * Creates an esbuild plugin that transforms server functions for client use.
- * Replaces csrf() and route() calls with runtime lookups.
+ * Replaces csrf() calls with runtime lookups.
+ * Note: route() is now a global function defined in spa.js
  * @returns {import("esbuild").Plugin}
  */
 export function createServerFunctionsPlugin() {
@@ -176,7 +177,7 @@ export function createServerFunctionsPlugin() {
 
                 let source = await fs.promises.readFile(args.path, "utf8");
 
-                if (!source.includes("csrf(") && !source.includes("route(")) {
+                if (!source.includes("csrf(")) {
                     return null;
                 }
 
@@ -185,11 +186,6 @@ export function createServerFunctionsPlugin() {
                     "window.__NITRON_RUNTIME__.csrf"
                 );
 
-                source = source.replace(
-                    /\broute\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
-                    (_, routeName) => `window.__NITRON_RUNTIME__.routes["${routeName}"]`
-                );
-
                 const ext = args.path.split(".").pop();
                 const loader = ext === "tsx" ? "tsx" : ext === "ts" ? "ts" : ext === "jsx" ? "jsx" : "js";
 

package/lib/Console/Commands/MigrateCommand.js

@@ -1,6 +1,7 @@
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
 import Config from '../../Core/Config.js';
+import Environment from '../../Core/Environment.js';
 import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
 import seed from './SeedCommand.js';
 
@@ -8,6 +9,7 @@ export default async function migrate(options = {}) {
     const { seed: shouldSeed = false } = options;
 
     dotenv.config({ quiet: true });
+    Environment.setDev(true);
     await Config.initialize();
 
     try {

package/lib/Console/Commands/MigrateFreshCommand.js

@@ -1,6 +1,7 @@
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
 import Config from '../../Core/Config.js';
+import Environment from '../../Core/Environment.js';
 import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
 import Output from '../../Console/Output.js';
 import seed from './SeedCommand.js';
@@ -9,6 +10,7 @@ export default async function migrateFresh(options = {}) {
     const { seed: shouldSeed = false } = options;
 
     dotenv.config({ quiet: true });
+    Environment.setDev(true);
     await Config.initialize();
 
     try {

package/lib/Console/Commands/MigrateRollbackCommand.js

@@ -1,6 +1,7 @@
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
 import Config from '../../Core/Config.js';
+import Environment from '../../Core/Environment.js';
 import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
 import Output from '../../Console/Output.js';
 
@@ -8,6 +9,7 @@ export default async function rollback(options = {}) {
     const { step = 1, all = false } = options;
 
     dotenv.config({ quiet: true });
+    Environment.setDev(true);
     await Config.initialize();
 
     try {

package/lib/Console/Commands/MigrateStatusCommand.js

@@ -1,11 +1,13 @@
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
 import Config from '../../Core/Config.js';
+import Environment from '../../Core/Environment.js';
 import MigrationRunner from '../../Database/Migration/MigrationRunner.js';
 import Output from '../../Console/Output.js';
 
 export default async function status() {
     dotenv.config({ quiet: true });
+    Environment.setDev(true);
     await Config.initialize();
 
     try {

package/lib/Console/Commands/SeedCommand.js

@@ -1,10 +1,12 @@
 import dotenv from 'dotenv';
 import DB from '../../Database/DB.js';
 import Config from '../../Core/Config.js';
+import Environment from '../../Core/Environment.js';
 import SeederRunner from '../../Database/Seeder/SeederRunner.js';
 
 export default async function seed(seederName = null) {
     dotenv.config({ quiet: true });
+    Environment.setDev(true);
     await Config.initialize();
 
     try {

package/lib/Database/Drivers/MySQLDriver.js

@@ -154,13 +154,17 @@ class MySQLDriver {
     #handleError(error, sql, bindings = null) {
         if (Environment.isProd) {
             console.error("[MySQLDriver] Query failed", {
+                message: error.message,
                 code: error.code,
                 errno: error.errno,
-                sqlState: error.sqlState
+                sqlState: error.sqlState,
+                sql: sql?.substring(0, 200)
             });
 
             const sanitized = new Error("Database query failed");
             sanitized.code = error.code;
+            sanitized.errno = error.errno;
+            sanitized.sqlState = error.sqlState;
             sanitized.driver = "mysql";
 
             return sanitized;

package/lib/Database/Migration/MigrationRunner.js

@@ -50,6 +50,8 @@ class MigrationRunner {
             Output.frameworkMigration('done', file);
         }
 
+        Output.newline();
+
         return { success: true, ran };
     }
 

package/lib/Database/Model.js

@@ -247,4 +247,24 @@ function hydrate(modelClass, row) {
     return instance;
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// QueryBuilder Method Forwarding
+// Automatically forward all QueryBuilder methods to Model for fluent chaining
+// ─────────────────────────────────────────────────────────────────────────────
+
+const QUERY_METHODS = [
+    // Chain methods (return QueryBuilder)
+    'distinct', 'orWhere', 'whereIn', 'whereNotIn',
+    'whereBetween', 'whereNot', 'join', 'groupBy', 'offset',
+    // Terminal methods (return results)
+    'count', 'max', 'min', 'sum', 'avg', 'delete'
+];
+
+for (const method of QUERY_METHODS) {
+    Model[method] = function(...args) {
+        ensureTable(this);
+        return DB.table(this.table, null, this)[method](...args);
+    };
+}
+
 export default Model;

package/lib/Database/QueryBuilder.js

@@ -135,8 +135,10 @@ class QueryBuilder {
                 message: error.message,
                 code: error.code,
                 errno: error.errno,
-                sql: error.sql?.substring(0, 100),
-                sqlState: error.sqlState
+                sqlState: error.sqlState,
+                sql: error.sql?.substring(0, 200),
+                bindings: error.bindings,
+                driver: error.driver
             });
 
             const sanitized = new Error('Database query failed. Please contact support if the problem persists.');
@@ -297,24 +299,14 @@ class QueryBuilder {
         return this;
     }
 
-    whereNull(column) {
-        this.#wheres.push({
-            type: 'null',
-            column: this.#validateIdentifier(column),
-            boolean: 'AND'
-        });
-
-        return this;
-    }
-
-    whereNotNull(column) {
-        this.#wheres.push({
-            type: 'notNull',
-            column: this.#validateIdentifier(column),
-            boolean: 'AND'
-        });
-
-        return this;
+    /**
+     * Add a WHERE NOT (!=) clause.
+     * @param {string} column - Column name
+     * @param {*} value - Value to compare
+     * @returns {QueryBuilder}
+     */
+    whereNot(column, value) {
+        return this.where(column, '!=', value);
     }
 
     whereBetween(column, values) {
@@ -334,22 +326,6 @@ class QueryBuilder {
         return this;
     }
 
-    whereRaw(sql, bindings = []) {
-        if (typeof sql !== 'string' || sql.length === 0) {
-            throw new Error('whereRaw requires non-empty SQL string');
-        }
-
-        this.#wheres.push({
-            type: 'raw',
-            sql,
-            boolean: 'AND'
-        });
-
-        this.#bindings.push(...bindings);
-
-        return this;
-    }
-
     join(table, first, operator, second, type = 'inner') {
         if (arguments.length === 3) {
             second = operator;
@@ -370,14 +346,6 @@ class QueryBuilder {
         return this;
     }
 
-    leftJoin(table, first, operator, second) {
-        return this.join(table, first, operator, second, 'left');
-    }
-
-    rightJoin(table, first, operator, second) {
-        return this.join(table, first, operator, second, 'right');
-    }
-
     orderBy(column, direction = 'ASC') {
         this.#orders.push({
             column: this.#validateIdentifier(column),
@@ -394,25 +362,6 @@ class QueryBuilder {
         return this;
     }
 
-    having(column, operator, value) {
-        if (arguments.length === 2) {
-            value = operator;
-            operator = '=';
-        }
-
-        operator = this.#validateWhereOperator(operator);
-
-        this.#havings.push({
-            column: this.#validateIdentifier(column),
-            operator,
-            value
-        });
-        this.#bindings.push(value);
-
-
-        return this;
-    }
-
     limit(value) {
         this.#limitValue = this.#validateInteger(value);
 
@@ -425,10 +374,6 @@ class QueryBuilder {
         return this;
     }
 
-    forPage(page, perPage = 15) {
-        return this.offset((page - 1) * perPage).limit(perPage);
-    }
-
     async get() {
         const connection = await this.#getConnection();
 
@@ -740,13 +685,6 @@ class QueryBuilder {
         return sql;
     }
 
-    toSql() {
-        return this.#toSql();
-    }
-
-    getBindings() {
-        return [...this.#bindings];
-    }
 }
 
 export class RawExpression {

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/Filesystem/Storage.js

@@ -65,6 +65,25 @@ class Storage {
         await fs.promises.unlink(fullPath);
     }
 
+    /**
+     * Moves or renames a file in storage.
+     * @param {string} fromPath - Current relative path to the file
+     * @param {string} toPath - New relative path for the file
+     * @param {boolean} isPrivate - Whether to operate on private storage
+     * @returns {Promise<void>}
+     */
+    static async move(fromPath, toPath, isPrivate = false) {
+        const base = isPrivate ? this.#privateRoot : this.#publicRoot;
+        const fullFromPath = this.#validatePath(base, fromPath);
+        const fullToPath = this.#validatePath(base, toPath);
+
+        // Ensure target directory exists
+        const targetDir = path.dirname(fullToPath);
+        await fs.promises.mkdir(targetDir, { recursive: true });
+
+        await fs.promises.rename(fullFromPath, fullToPath);
+    }
+
     /**
      * Checks if a file exists in storage.
      * @param {string} filePath - Relative path to the file

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"
@@ -171,6 +208,8 @@ class Server {
             for (const [key, field] of Object.entries(req.body)) {
                 if (field?.toBuffer) {
                     if (field.filename) {
+                        const lastDot = field.filename.lastIndexOf(".");
+                        field.extension = lastDot > 0 ? field.filename.slice(lastDot + 1).toLowerCase() : "";
                         files[key] = field;
                     }
                 }

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/Client/spa.js

@@ -6,6 +6,28 @@
     var layouts = [];
     var navigating = false;
 
+    // Route helper function for client-side
+    globalThis.route = function(name, params) {
+        var runtime = window.__NITRON_RUNTIME__;
+        if (!runtime || !runtime.routes) {
+            console.error("Route runtime not initialized");
+            return "";
+        }
+
+        var pattern = runtime.routes[name];
+        if (!pattern) {
+            console.error('Route "' + name + '" not found');
+            return "";
+        }
+
+        if (!params) return pattern;
+
+        // Replace :param tokens with actual values
+        return pattern.replace(/:(\w+)/g, function(match, key) {
+            return params[key] !== undefined ? params[key] : match;
+        });
+    };
+
     function init() {
         var rt = window.__NITRON_RUNTIME__;
         if (rt && rt.layouts) layouts = rt.layouts;

package/lib/View/View.js

@@ -291,120 +291,134 @@ 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);
+                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) {
+    static #mergeMeta(layoutModules, viewMeta, params = {}) {
         const result = {};
 
         for (const layoutMod of layoutModules) {
             if (layoutMod.Meta) {
-                for (const key of Object.keys(layoutMod.Meta)) {
+                const resolvedLayoutMeta = typeof layoutMod.Meta === "function" 
+                    ? layoutMod.Meta(params) 
+                    : layoutMod.Meta;
+                for (const key of Object.keys(resolvedLayoutMeta)) {
                     if (!(key in result)) {
-                        result[key] = layoutMod.Meta[key];
+                        result[key] = resolvedLayoutMeta[key];
                     }
                 }
             }
         }
 
         if (viewMeta) {
-            for (const key of Object.keys(viewMeta)) {
+            const resolvedViewMeta = typeof viewMeta === "function" 
+                ? viewMeta(params) 
+                : viewMeta;
+            for (const key of Object.keys(resolvedViewMeta)) {
                 if (key === "title" && result.title?.template) {
-                    const viewTitle = typeof viewMeta.title === "object"
-                        ? viewMeta.title.default
-                        : viewMeta.title;
+                    const viewTitle = typeof resolvedViewMeta.title === "object"
+                        ? resolvedViewMeta.title.default
+                        : resolvedViewMeta.title;
                     if (viewTitle) {
                         result.title = result.title.template.replace("%s", viewTitle);
                     }
                 } else {
-                    result[key] = viewMeta[key];
+                    result[key] = resolvedViewMeta[key];
                 }
             }
         }
@@ -648,8 +662,16 @@ class View {
                 }
 
                 const content = readFileSync(fullPath, "utf8");
-                const matches = [...content.matchAll(/routes\["([^"]+)"\]/g)];
-                const routes = matches.map(match => match[1]);
+                
+                // Match both old format (routes["name"]) and new format (route("name"))
+                const oldMatches = [...content.matchAll(/routes\["([^"]+)"\]/g)];
+                const newMatches = [...content.matchAll(/route\s*\(\s*['"]([^'"]+)['"]/g)];
+                
+                const routes = [
+                    ...oldMatches.map(match => match[1]),
+                    ...newMatches.map(match => match[1])
+                ];
+                
                 const relativePath = "/js/" + path.relative(jsDir, fullPath).replace(/\\/g, "/");
 
                 this.#routesCache.set(relativePath, [...new Set(routes)]);
@@ -701,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>
@@ -724,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

@@ -1,15 +1,51 @@
 export class Storage {
-    static url(path: string): string;
-    static path(path: string): string;
-    static disk(name: string): Storage;
-    static get(path: string): Promise<Buffer>;
-    static put(path: string, contents: string | Buffer): Promise<void>;
-    static delete(path: string): Promise<boolean>;
-    static exists(path: string): Promise<boolean>;
-    static copy(from: string, to: string): Promise<void>;
-    static move(from: string, to: string): Promise<void>;
-    static files(directory: string): Promise<string[]>;
-    static directories(directory: string): Promise<string[]>;
+    /**
+     * Reads a file from storage.
+     * @param filePath - Relative path to the file
+     * @param isPrivate - Whether to read from private storage (default: false)
+     * @returns File contents or null if not found
+     */
+    static get(filePath: string, isPrivate?: boolean): Promise<Buffer | null>;
+
+    /**
+     * Saves a file to storage.
+     * @param file - File object from multipart upload
+     * @param dir - Directory path within storage
+     * @param fileName - Name for the saved file
+     * @param isPrivate - Whether to save to private storage (default: false)
+     * @returns True if save successful
+     */
+    static put(file: { _buf: Buffer }, dir: string, fileName: string, isPrivate?: boolean): Promise<boolean>;
+
+    /**
+     * Deletes a file from storage.
+     * @param filePath - Relative path to the file
+     * @param isPrivate - Whether to delete from private storage (default: false)
+     */
+    static delete(filePath: string, isPrivate?: boolean): Promise<void>;
+
+    /**
+     * Moves or renames a file in storage.
+     * @param fromPath - Current relative path to the file
+     * @param toPath - New relative path for the file
+     * @param isPrivate - Whether to operate on private storage (default: false)
+     */
+    static move(fromPath: string, toPath: string, isPrivate?: boolean): Promise<void>;
+
+    /**
+     * Checks if a file exists in storage.
+     * @param filePath - Relative path to the file
+     * @param isPrivate - Whether to check private storage (default: false)
+     * @returns True if file exists
+     */
+    static exists(filePath: string, isPrivate?: boolean): boolean;
+
+    /**
+     * Gets the public URL for a file in public storage.
+     * @param filePath - Relative path to the file
+     * @returns Public URL path
+     */
+    static url(filePath: string): string;
 }
 
 export class Model {
@@ -20,9 +56,8 @@ export class Model {
     static hidden: string[];
     static casts: Record<string, string>;
 
-    static all<T extends Model>(this: new () => T): Promise<T[]>;
+    static get<T extends Model>(this: new () => T): Promise<T[]>;
     static find<T extends Model>(this: new () => T, id: number | string): Promise<T | null>;
-    static findOrFail<T extends Model>(this: new () => T, id: number | string): Promise<T>;
     static first<T extends Model>(this: new () => T): Promise<T | null>;
     static where<T extends Model>(this: new () => T, column: string, operator?: any, value?: any): QueryBuilder<T>;
     static select<T extends Model>(this: new () => T, ...columns: string[]): QueryBuilder<T>;
@@ -189,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;
@@ -468,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;
@@ -480,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.12",
+	"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/*"],