@wxn0brp/falcon-frame 0.0.21 → 0.2.0

package/dist/body.d.ts

@@ -0,0 +1,3 @@
+import FalconFrame from "./index.js";
+import { FFRequest, ParseBody } from "./types.js";
+export declare function parseBody(req: FFRequest, body: string, FF: FalconFrame): Promise<ParseBody>;

package/dist/body.js

@@ -0,0 +1,52 @@
+import querystring from "querystring";
+const parseBodyFunctions = {
+    "application/json": async (body) => ({ body: JSON.parse(body) }),
+    "application/x-www-form-urlencoded": async (body) => ({
+        body: querystring.parse(body),
+    }),
+};
+export async function parseBody(req, body, FF) {
+    const funcs = Object.assign({}, parseBodyFunctions, FF.customParsers || {});
+    const limit = parseLimit(FF.opts.bodyLimit);
+    try {
+        if (limit && body.length > limit) {
+            await FF.logger.warn(`Body size exceeds limit of ${limit} bytes`);
+            return {};
+        }
+        const type = req.headers["content-type"] || "";
+        const func = funcs[type];
+        if (!func)
+            return {};
+        const data = await func(body, req, FF);
+        if (!data || typeof data !== "object")
+            return {};
+        return data;
+    }
+    catch (e) {
+        await FF.logger.warn(`Error parsing body: ${e}`);
+        return {};
+    }
+}
+function parseLimit(limit) {
+    if (!limit)
+        return 0;
+    if (typeof limit === "number")
+        return limit;
+    if (typeof limit !== "string")
+        return 0;
+    const match = limit.match(/^(\d+)([kmg])?$/i);
+    if (!match)
+        return 0;
+    const num = parseInt(match[1], 10);
+    const unit = match[2]?.toLowerCase();
+    switch (unit) {
+        case "k":
+            return num * 1024;
+        case "m":
+            return num * 1024 * 1024;
+        case "g":
+            return num * 1024 * 1024 * 1024;
+        default:
+            return num;
+    }
+}

package/dist/helpers.d.ts

@@ -1,5 +1,4 @@
-import { Body, Cookies, RouteHandler } from "./types.js";
+import { Cookies, RouteHandler, StaticServeOptions } from "./types.js";
 export declare function parseCookies(cookieHeader: string): Cookies;
-export declare function parseBody(contentType: string, body: string): Body;
 export declare function getContentType(filePath: string, utf8?: boolean): string;
-export declare function handleStaticFiles(dirPath: string, utf8?: boolean): RouteHandler;
+export declare function handleStaticFiles(dirPath: string, opts: StaticServeOptions): RouteHandler;

package/dist/helpers.js

@@ -1,58 +1,31 @@
 import fs from "fs";
 import path from "path";
-import querystring from "querystring";
 export function parseCookies(cookieHeader) {
     const cookies = {};
-    cookieHeader.split(";").forEach(cookie => {
+    cookieHeader.split(";").forEach((cookie) => {
         const [name, ...valueParts] = cookie.split("=");
         const value = decodeURIComponent(valueParts.join("=").trim());
         cookies[name.trim()] = value;
     });
     return cookies;
 }
-export function parseBody(contentType, body) {
-    if (contentType.includes("application/json")) {
-        try {
-            return JSON.parse(body);
-        }
-        catch {
-            return {};
-        }
-    }
-    else if (contentType.includes("application/x-www-form-urlencoded")) {
-        return querystring.parse(body);
-    }
-    return {};
-}
+const mimeTypes = {
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".txt": "text/plain",
+    ".pdf": "application/pdf",
+};
 function _getContentType(filePath) {
     const ext = path.extname(filePath).toLowerCase();
-    switch (ext) {
-        case ".html":
-            return "text/html";
-        case ".css":
-            return "text/css";
-        case ".js":
-            return "application/javascript";
-        case ".json":
-            return "application/json";
-        case ".png":
-            return "image/png";
-        case ".jpg":
-        case ".jpeg":
-            return "image/jpeg";
-        case ".gif":
-            return "image/gif";
-        case ".svg":
-            return "image/svg+xml";
-        case ".ico":
-            return "image/x-icon";
-        case ".txt":
-            return "text/plain";
-        case ".pdf":
-            return "application/pdf";
-        default:
-            return "application/octet-stream";
-    }
+    return mimeTypes[ext] || "application/octet-stream";
 }
 export function getContentType(filePath, utf8 = false) {
     let contentType = _getContentType(filePath);
@@ -60,34 +33,83 @@ export function getContentType(filePath, utf8 = false) {
         contentType += "; charset=utf-8";
     return contentType;
 }
-export function handleStaticFiles(dirPath, utf8 = true) {
+export function handleStaticFiles(dirPath, opts) {
+    opts = {
+        utf8: true,
+        render: true,
+        etag: true,
+        ...opts,
+    };
+    if (!fs.existsSync(dirPath)) {
+        throw new Error(`Directory ${dirPath} does not exist`);
+    }
+    const serveFile = (req, res, filePath, stats) => {
+        if (opts.etag) {
+            const etag = `W/"${stats.size}-${stats.mtime.getTime()}"`;
+            if (req.headers["if-none-match"] === etag) {
+                res.status(304).end();
+                return true;
+            }
+            res.setHeader("ETag", etag);
+        }
+        if (opts.render && filePath.endsWith(".html")) {
+            res.ct("text/html");
+            res.render(filePath);
+            return true;
+        }
+        res.ct(getContentType(filePath, opts.utf8));
+        fs.createReadStream(filePath).pipe(res);
+        return true;
+    };
     return (req, res, next) => {
         if (req.method.toLowerCase() !== "get")
             return next();
         const apiPath = req.middleware.path;
         const filePath = path.join(dirPath, req.path.replace(apiPath, ""));
-        if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-            res.ct(getContentType(filePath, utf8));
-            fs.createReadStream(filePath).pipe(res);
-            return true;
+        try {
+            const stats = fs.statSync(filePath);
+            if (stats.isFile()) {
+                return serveFile(req, res, filePath, stats);
+            }
+            if (stats.isDirectory()) {
+                const indexPath = path.join(filePath, "index.html");
+                try {
+                    const indexStats = fs.statSync(indexPath);
+                    if (indexStats.isFile()) {
+                        if (!req.path.endsWith("/")) {
+                            res.redirect(req.path + "/");
+                            return true;
+                        }
+                        return serveFile(req, res, indexPath, indexStats);
+                    }
+                }
+                catch (e) {
+                    /* index.html not found, do nothing */
+                }
+            }
         }
-        if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
-            const indexPath = path.join(filePath, "index.html");
-            if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
-                if (!req.path.endsWith("/")) {
-                    res.redirect(req.path + "/");
-                    return true;
+        catch (e) {
+            /* file/dir not found, proceed to check for .html */
+        }
+        try {
+            const htmlPath = filePath + ".html";
+            const htmlStats = fs.statSync(htmlPath);
+            if (htmlStats.isFile()) {
+                if (opts.etag) {
+                    const etag = `W/"${htmlStats.size}-${htmlStats.mtime.getTime()}"`;
+                    if (req.headers["if-none-match"] === etag) {
+                        res.status(304).end();
+                        return true;
+                    }
+                    res.setHeader("ETag", etag);
                 }
-                res.ct(getContentType(indexPath, utf8));
-                fs.createReadStream(indexPath).pipe(res);
+                res.ct(getContentType(htmlPath, opts.utf8));
+                fs.createReadStream(htmlPath).pipe(res);
                 return true;
             }
         }
-        const htmlPath = filePath + ".html";
-        if (fs.existsSync(htmlPath) && fs.statSync(htmlPath).isFile()) {
-            res.ct(getContentType(htmlPath, utf8));
-            fs.createReadStream(htmlPath).pipe(res);
-            return true;
+        catch (e) {
+            /* .html file not found, fall through to next() */
         }
         next();
     };

package/dist/index.d.ts

@@ -1,18 +1,38 @@
 import { Logger, LoggerOptions } from "@wxn0brp/lucerna-log";
 import http from "http";
-import { PluginSystem } from "./plugins.js";
+import { PluginSystem } from "./plugin.js";
 import { renderHTML } from "./render.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
-import { BeforeHandleRequest, FFRequest, RouteHandler } from "./types.js";
-export declare class FalconFrame extends Router {
+import type { BeforeHandleRequest, FFRequest, ParseBodyFunction, RouteHandler } from "./types.js";
+export type EngineCallback = (path: string, options: any, callback: (e: any, rendered?: string) => void) => void;
+export interface Opts {
+    loggerOpts?: LoggerOptions;
+    bodyLimit?: string;
+}
+export declare class FalconFrame<Vars extends Record<string, any> = any> extends Router {
     logger: Logger;
-    constructor(loggerOpts?: LoggerOptions);
+    customParsers: Record<string, ParseBodyFunction>;
+    vars: Vars;
+    opts: Opts;
+    engines: Record<string, EngineCallback>;
+    constructor(opts?: Partial<Opts>);
     listen(port: number, callback?: (() => void) | boolean, beforeHandleRequest?: BeforeHandleRequest): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
     getApp(beforeHandleRequest?: BeforeHandleRequest): (req: any, res: any) => Promise<void>;
+    engine(ext: string, callback: EngineCallback): this;
+    setVar(key: keyof Vars, value: typeof this.vars[keyof Vars]): void;
+    getVar(key: string): typeof this.vars[keyof Vars];
+    /**
+     * Sets the allowed origins for CORS.
+     * This method is a shortcut that simplifies CORS configuration
+     * without needing to manually create and register a plugin.
+     * @param origin - An array of allowed origins.
+     * @example
+     * app.setOrigin(["http://example.com", "https://example.com"]);
+    */
+    setOrigin(origin: string[]): void;
 }
 export default FalconFrame;
-export { FFRequest, FFResponse, PluginSystem, renderHTML, RouteHandler, Router };
-export * as Plugins from "./plugins/index.js";
-export * as PluginsEngine from "./plugins.js";
 export * as Helpers from "./helpers.js";
+export * as PluginsEngine from "./plugin.js";
+export { FFRequest, FFResponse, PluginSystem, renderHTML, RouteHandler, Router };

package/dist/index.js

@@ -1,18 +1,35 @@
 import { Logger } from "@wxn0brp/lucerna-log";
 import http from "http";
-import { PluginSystem } from "./plugins.js";
+import { PluginSystem } from "./plugin.js";
+import { createCORSPlugin } from "./plugins/cors.js";
 import { renderHTML } from "./render.js";
 import { handleRequest } from "./req.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
-import { FFRequest } from "./types.js";
 export class FalconFrame extends Router {
     logger;
-    constructor(loggerOpts) {
+    customParsers = {};
+    vars = {};
+    opts = {};
+    engines = {};
+    constructor(opts = {}) {
         super();
         this.logger = new Logger({
             loggerName: "falcon-frame",
-            ...loggerOpts
+            ...[opts?.loggerOpts || {}],
+        });
+        this.opts = {
+            bodyLimit: "10m",
+            ...opts,
+        };
+        this.engine(".html", (path, options, callback) => {
+            try {
+                const content = renderHTML(path, options);
+                callback(null, content);
+            }
+            catch (e) {
+                callback(e);
+            }
         });
     }
     listen(port, callback, beforeHandleRequest) {
@@ -38,9 +55,34 @@ export class FalconFrame extends Router {
             await handleRequest(req, res, this);
         };
     }
+    engine(ext, callback) {
+        if (ext[0] !== ".") {
+            ext = "." + ext;
+        }
+        this.engines[ext] = callback;
+        return this;
+    }
+    setVar(key, value) {
+        // @ts-ignore
+        this.vars[key] = value;
+    }
+    getVar(key) {
+        // @ts-ignore
+        return this.vars[key];
+    }
+    /**
+     * Sets the allowed origins for CORS.
+     * This method is a shortcut that simplifies CORS configuration
+     * without needing to manually create and register a plugin.
+     * @param origin - An array of allowed origins.
+     * @example
+     * app.setOrigin(["http://example.com", "https://example.com"]);
+    */
+    setOrigin(origin) {
+        this.use(createCORSPlugin(origin).process);
+    }
 }
 export default FalconFrame;
-export { FFRequest, FFResponse, PluginSystem, renderHTML, Router };
-export * as Plugins from "./plugins/index.js";
-export * as PluginsEngine from "./plugins.js";
 export * as Helpers from "./helpers.js";
+export * as PluginsEngine from "./plugin.js";
+export { FFResponse, PluginSystem, renderHTML, Router };

package/dist/{plugins.d.ts → plugin.d.ts}

@@ -3,7 +3,8 @@ export type PluginId = string;
 export interface Plugin {
     id: PluginId;
     process: RouteHandler;
-    priority?: number;
+    before?: PluginId | PluginId[];
+    after?: PluginId | PluginId[];
 }
 export interface PluginOptions {
     before?: PluginId | PluginId[];

package/dist/{plugins.js → plugin.js}

@@ -7,30 +7,29 @@ export class PluginSystem {
      * @param options - Options for positioning plugins
      */
     register(plugin, options) {
-        if (this.plugins.some(p => p.id === plugin.id)) {
+        if (this.plugins.some((p) => p.id === plugin.id)) {
             throw new Error(`Plugin with id '${plugin.id}' already registered`);
         }
-        // Add plugin to the list
         this.plugins.push(plugin);
-        // Update the execution order
-        this.updateExecutionOrder(plugin.id, options);
+        this.updateExecutionOrder(plugin, options);
     }
     /**
      * Updates the execution order of plugins
      * @param pluginId - ID of the plugin to position
      * @param options - Options for positioning
      */
-    updateExecutionOrder(pluginId, options) {
+    updateExecutionOrder(plugin, options) {
+        const pluginId = plugin.id;
         if (this.executionOrder.includes(pluginId))
             return;
         const resolveTarget = (target) => {
             if (!target)
                 return null;
             const list = Array.isArray(target) ? target : [target];
-            return list.find(id => this.executionOrder.includes(id)) || null;
+            return list.find((id) => this.executionOrder.includes(id)) || null;
         };
-        const beforeTarget = resolveTarget(options?.before);
-        const afterTarget = resolveTarget(options?.after);
+        const beforeTarget = resolveTarget(options?.before || plugin.before);
+        const afterTarget = resolveTarget(options?.after || plugin.after);
         if (beforeTarget) {
             const index = this.executionOrder.indexOf(beforeTarget);
             this.executionOrder.splice(index, 0, pluginId);
@@ -74,7 +73,7 @@ export class PluginSystem {
             return;
         }
         const pluginId = this.executionOrder[index];
-        const plugin = this.plugins.find(p => p.id === pluginId);
+        const plugin = this.plugins.find((p) => p.id === pluginId);
         if (!plugin) {
             throw new Error(`Plugin '${pluginId}' not found`);
         }
@@ -87,7 +86,7 @@ export class PluginSystem {
      */
     getPluginsInOrder() {
         return this.executionOrder
-            .map(id => this.plugins.find(p => p.id === id))
+            .map((id) => this.plugins.find((p) => p.id === id))
             .filter((p) => p !== undefined);
     }
 }

package/dist/plugins/cors.d.ts

@@ -1,7 +1,8 @@
-import { Plugin } from "../plugins.js";
+import { Plugin } from "../plugin.js";
 interface Opts {
     accessControlAllowMethods?: boolean;
     accessControlAllowHeaders?: boolean;
+    headers?: Record<string, string>;
 }
 export declare function createCORSPlugin(allowedOrigins: string[], opts?: Opts): Plugin;
 export {};

package/dist/plugins/cors.js

@@ -13,6 +13,11 @@ export function createCORSPlugin(allowedOrigins, opts = {}) {
     return {
         id: "cors",
         process: (req, res, next) => {
+            if (opts.headers) {
+                for (const [key, value] of Object.entries(opts.headers)) {
+                    res.setHeader(key, value);
+                }
+            }
             if (allowedOrigins.includes("*")) {
                 res.setHeader("Access-Control-Allow-Origin", "*");
                 setHeader(res, opts);

package/dist/plugins/rateLimit.d.ts

@@ -1,2 +1,2 @@
-import { Plugin } from "../plugins.js";
+import { Plugin } from "../plugin.js";
 export declare function createRateLimiterPlugin(maxRequests: number, windowMs: number): Plugin;

package/dist/plugins/security.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "../plugin.js";
+export declare function createSecurityPlugin(): Plugin;

package/dist/plugins/security.js

@@ -0,0 +1,14 @@
+export function createSecurityPlugin() {
+    return {
+        id: "security",
+        process: (req, res, next) => {
+            res.setHeader("X-Content-Type-Options", "nosniff");
+            res.setHeader("X-Frame-Options", "SAMEORIGIN");
+            res.setHeader("Referrer-Policy", "no-referrer");
+            res.setHeader("X-XSS-Protection", "1; mode=block");
+            res.setHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
+            next();
+        },
+        after: "cors",
+    };
+}

package/dist/render.d.ts

@@ -1,5 +1,5 @@
 interface RenderData {
     [key: string]: string;
 }
-export declare function renderHTML(templatePath: string, data: RenderData): string;
+export declare function renderHTML(templatePath: string, data: RenderData, renderedPaths?: string[]): string;
 export {};

package/dist/render.js

@@ -1,18 +1,25 @@
 import fs from "fs";
 import path from "path";
-export function renderHTML(templatePath, data) {
-    if (!fs.existsSync(templatePath))
-        return "Template not found";
-    let template = fs.readFileSync(templatePath, "utf8");
-    // Inserting data, e.g. {{name}}
-    template = template.replace(/{{(.*?)}}/g, (_, key) => data[key.trim()] || "");
-    // Loading partials, e.g. <!-- include header -->
-    template = template.replace(/<!--\s*include\s*(.*?)\s*-->/g, (_, partialName) => {
-        const partialPath = path.join(path.dirname(templatePath), partialName + ".html");
-        if (fs.existsSync(partialPath))
-            return renderHTML(partialPath, data);
-        else
-            return `<!-- Partial "${partialName}" (${partialPath.replace(process.cwd() + "/", "")}) not found -->`;
-    });
-    return template;
+export function renderHTML(templatePath, data, renderedPaths = []) {
+    try {
+        const realPath = path.resolve(templatePath);
+        if (renderedPaths.includes(realPath)) {
+            return `<!-- Circular dependency detected: tried to render ${templatePath} again -->`;
+        }
+        let template = fs.readFileSync(templatePath, "utf8");
+        // Inserting data, e.g. {{name}}
+        template = template.replace(/{{(.*?)}}/g, (_, key) => data[key.trim()] || "");
+        // Loading partials, e.g. <!-- include header -->
+        template = template.replace(/<!--\s*include\s*(.*?)\s*-->/g, (_, partialName) => {
+            const partialPath = path.join(path.dirname(templatePath), partialName + ".html");
+            return renderHTML(partialPath, data, [
+                ...renderedPaths,
+                realPath,
+            ]);
+        });
+        return template;
+    }
+    catch (error) {
+        return `<!-- Template not found: ${templatePath} -->`;
+    }
 }

package/dist/req.js

@@ -1,10 +1,12 @@
 import { URL } from "url";
-import { parseBody, parseCookies } from "./helpers.js";
+import { parseCookies } from "./helpers.js";
 import { FFResponse } from "./res.js";
 import { validate } from "./valid.js";
 import { getMiddlewares, matchMiddleware } from "./middleware.js";
+import { parseBody } from "./body.js";
 export function handleRequest(req, res, FF) {
     Object.setPrototypeOf(res, FFResponse.prototype);
+    res.FF = FF;
     const originalEnd = res.end;
     res.end = function (...any) {
         res._ended = true;
@@ -29,9 +31,11 @@ export function handleRequest(req, res, FF) {
     logger.info(`Incoming request: ${req.method} ${req.url}`);
     const middlewaresPath = req.path + "/";
     const middlewares = getMiddlewares(FF.middlewares, middlewaresPath.replace(/\/+/g, "/"));
-    const matchedTypeMiddlewares = middlewares.filter(middleware => middleware.method === req.method.toLowerCase() || middleware.method === "all");
+    const matchedTypeMiddlewares = middlewares.filter((middleware) => middleware.method === req.method.toLowerCase() ||
+        middleware.method === "all");
     const matchedMiddlewares = matchMiddleware(req.path, matchedTypeMiddlewares);
-    logger.debug("Matched middlewares: " + matchedMiddlewares.map(middleware => middleware.path).join(", "));
+    logger.debug("Matched middlewares: " +
+        matchedMiddlewares.map((middleware) => middleware.path).join(", "));
     if (matchedMiddlewares.length === 0) {
         res.status(404).end("404: File had second thoughts");
         return;
@@ -67,15 +71,18 @@ export function handleRequest(req, res, FF) {
             }
         }
     }
-    if (req.method === "GET" && middlewares[middlewares.length - 1]?.sse) {
+    if (req.method === "GET" ||
+        req.method === "HEAD" ||
+        req.method === "OPTIONS") {
+        req.body = {};
         next();
         return;
     }
     let body = "";
-    req.on("data", chunk => (body += chunk.toString()));
-    req.on("end", () => {
-        const contentType = req.headers["content-type"] || "";
-        req.body = parseBody(contentType, body);
+    req.on("data", (chunk) => (body += chunk.toString()));
+    req.on("end", async () => {
+        const parsedBody = await parseBody(req, body, FF);
+        Object.assign(req, parsedBody);
         logger.debug(`Request body: ${JSON.stringify(req.body)}`);
         next();
     });

package/dist/res.d.ts

@@ -1,10 +1,12 @@
 import http from "http";
+import FalconFrame from "./index.js";
 import { CookieOptions } from "./types.js";
 export declare class FFResponse extends http.ServerResponse {
     _ended: boolean;
+    FF: FalconFrame;
     /**
      * bind end for compatibility
-    */
+     */
     send(data: string): void;
     /**
      * Sets a header. This is a shortcut for setHeader.
@@ -54,13 +56,13 @@ export declare class FFResponse extends http.ServerResponse {
      */
     sendFile(filePath: string, contentType?: string): this;
     /**
-     * Renders an HTML template with the provided data and sends it as the response.
-     * Sets the "Content-Type" header to "text/html".
-     * @param templatePath The path to the HTML template file.
+     * Renders a view with the given data and sends it as the response.
+     * It uses the registered template engine.
+     * @param view The name of the view file to render.
      * @param data An object containing data to be injected into the template.
      * @returns The response object.
      */
-    render(templatePath: string, data?: any): this;
+    render(view: string, data?: any): this;
     /**
      * Initialize SSE headers to start a server-sent event stream.
      * Sets:

package/dist/res.js

@@ -1,12 +1,13 @@
+import { createReadStream } from "fs";
 import http from "http";
+import path from "path";
 import { getContentType } from "./helpers.js";
-import { createReadStream } from "fs";
-import { renderHTML } from "./render.js";
 export class FFResponse extends http.ServerResponse {
     _ended = false;
+    FF;
     /**
      * bind end for compatibility
-    */
+     */
     send(data) {
         this.end(data);
     }
@@ -97,15 +98,47 @@ export class FFResponse extends http.ServerResponse {
         return this;
     }
     /**
-     * Renders an HTML template with the provided data and sends it as the response.
-     * Sets the "Content-Type" header to "text/html".
-     * @param templatePath The path to the HTML template file.
+     * Renders a view with the given data and sends it as the response.
+     * It uses the registered template engine.
+     * @param view The name of the view file to render.
      * @param data An object containing data to be injected into the template.
      * @returns The response object.
      */
-    render(templatePath, data = {}) {
-        this.setHeader("Content-Type", "text/html");
-        this.end(renderHTML(templatePath, data));
+    render(view, data = {}) {
+        const ff = this.FF;
+        const viewEngine = ff.getVar("view engine");
+        const viewsDir = ff.getVar("views") || ".";
+        let finalExt = path.extname(view);
+        let filePath = view;
+        if (!finalExt) {
+            const defaultExt = viewEngine ? (viewEngine.startsWith(".") ? viewEngine : "." + viewEngine) : ".html";
+            finalExt = defaultExt;
+            filePath += finalExt;
+        }
+        const engine = ff.engines[finalExt];
+        if (!engine) {
+            const errMessage = `No engine registered for extension ${finalExt}`;
+            ff.logger.error(errMessage);
+            this.status(500).end("Server Error: " + errMessage);
+            return this;
+        }
+        const fullPath = path.resolve(viewsDir, filePath);
+        try {
+            engine(fullPath, data, (err, str) => {
+                if (err) {
+                    ff.logger.error(`Error rendering view: ${err}`);
+                    this.status(500).end("Server Error: Failed to render view.");
+                }
+                else {
+                    this.setHeader("Content-Type", "text/html");
+                    this.end(str);
+                }
+            });
+        }
+        catch (err) {
+            ff.logger.error(`Unhandled error in template engine: ${err}`);
+            this.status(500).end("Server Error: Unhandled exception in template engine.");
+        }
         return this;
     }
     /**

package/dist/router.d.ts

@@ -1,4 +1,4 @@
-import { Method, Middleware, RouteHandler } from "./types.js";
+import { Method, Middleware, RouteHandler, StaticServeOptions } from "./types.js";
 export declare class Router {
     middlewares: Middleware[];
     addRoute(method: Method, path: string, ...handlers: RouteHandler[]): number;
@@ -8,6 +8,6 @@ export declare class Router {
     put(path: string, ...handlers: RouteHandler[]): this;
     delete(path: string, ...handlers: RouteHandler[]): this;
     all(path: string, ...handlers: RouteHandler[]): this;
-    static(apiPath: string, dirPath?: string, utf8?: boolean): this;
+    static(apiPath: string, dirPath?: string, opts?: StaticServeOptions): this;
     sse(path: string, ...handlers: RouteHandler[]): this;
 }

package/dist/router.js

@@ -3,7 +3,7 @@ export class Router {
     middlewares = [];
     addRoute(method, path, ...handlers) {
         const handler = handlers.pop();
-        handlers.forEach(middleware => this.use(path, middleware));
+        handlers.forEach((middleware) => this.use(path, middleware));
         return this.middlewares.push({ path, middleware: handler, method });
     }
     use(path = "/", middlewareFn, method = "all") {
@@ -15,7 +15,7 @@ export class Router {
             path,
             method,
             middleware: null,
-            use: true
+            use: true,
         };
         if (middlewareFn instanceof Router) {
             middleware.router = middlewareFn.middlewares;
@@ -46,12 +46,12 @@ export class Router {
         this.addRoute("all", path, ...handlers);
         return this;
     }
-    static(apiPath, dirPath, utf8 = true) {
+    static(apiPath, dirPath, opts = {}) {
         if (!dirPath) {
             dirPath = apiPath;
             apiPath = "/";
         }
-        this.use(apiPath, handleStaticFiles(dirPath, utf8));
+        this.use(apiPath, handleStaticFiles(dirPath, opts));
         return this;
     }
     sse(path, ...handlers) {

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import FalconFrame from "./index.js";
 import { FFResponse } from "./res.js";
 import http from "http";
 export type RouteHandler = (req: FFRequest, res: FFResponse, next?: () => void) => void | any;
@@ -14,6 +15,11 @@ export interface Query {
 export interface Body {
     [key: string]: any;
 }
+export interface ParseBody {
+    body?: Body;
+    files?: Record<string, Buffer>;
+}
+export type ParseBodyFunction = (body: string, req: FFRequest, FF: FalconFrame) => Promise<ParseBody>;
 export declare class FFRequest extends http.IncomingMessage {
     path: string;
     query: Query;
@@ -48,3 +54,8 @@ export interface ValidationResult {
     };
 }
 export type BeforeHandleRequest = (req: http.IncomingMessage, res: http.ServerResponse) => any;
+export interface StaticServeOptions {
+    utf8?: boolean;
+    render?: boolean;
+    etag?: boolean;
+}

package/dist/valid.js

@@ -24,7 +24,8 @@ export function validate(schema, data) {
                     }
                     break;
                 case "min":
-                    if (typeof value === "string" && value.length < parseInt(param)) {
+                    if (typeof value === "string" &&
+                        value.length < parseInt(param)) {
                         fieldErrors.push(`${key} must be at least ${param} characters long`);
                     }
                     if (typeof value === "number" && value < parseInt(param)) {
@@ -32,7 +33,8 @@ export function validate(schema, data) {
                     }
                     break;
                 case "max":
-                    if (typeof value === "string" && value.length > parseInt(param)) {
+                    if (typeof value === "string" &&
+                        value.length > parseInt(param)) {
                         fieldErrors.push(`${key} must not exceed ${param} characters`);
                     }
                     if (typeof value === "number" && value > parseInt(param)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.0.21",
+  "version": "0.2.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -12,12 +12,12 @@
     "url": "https://github.com/wxn0brP/FalconFrame.git"
   },
   "devDependencies": {
-    "@types/node": "^22.12.0",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3"
+    "@types/node": "*",
+    "tsc-alias": "*",
+    "typescript": "*"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.1.1"
+    "@wxn0brp/lucerna-log": "^0.2.0"
   },
   "files": [
     "dist"

package/dist/plugins/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./cors.js";
-export * from "./rateLimit.js";

package/dist/plugins/index.js

@@ -1,2 +0,0 @@
-export * from "./cors.js";
-export * from "./rateLimit.js";