@wxn0brp/falcon-frame 0.0.20 → 0.1.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,46 @@
+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 } 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;

package/dist/helpers.js

@@ -1,6 +1,5 @@
 import fs from "fs";
 import path from "path";
-import querystring from "querystring";
 export function parseCookies(cookieHeader) {
     const cookies = {};
     cookieHeader.split(";").forEach(cookie => {
@@ -10,20 +9,6 @@ export function parseCookies(cookieHeader) {
     });
     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 {};
-}
 function _getContentType(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
@@ -83,6 +68,12 @@ export function handleStaticFiles(dirPath, utf8 = true) {
                 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;
+        }
         next();
     };
 }

package/dist/index.d.ts

@@ -4,15 +4,24 @@ import { PluginSystem } from "./plugins.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 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;
+    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>;
+    setVar(key: keyof Vars, value: typeof this.vars[keyof Vars]): void;
+    getVar(key: string): typeof this.vars[keyof Vars];
 }
 export default FalconFrame;
-export { FFRequest, FFResponse, PluginSystem, renderHTML, RouteHandler, Router };
+export { FFRequest, FFResponse, PluginSystem, renderHTML, Router, RouteHandler };
 export * as Plugins from "./plugins/index.js";
 export * as PluginsEngine from "./plugins.js";
 export * as Helpers from "./helpers.js";

package/dist/index.js

@@ -5,15 +5,21 @@ 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 = {};
+    constructor(opts = {}) {
         super();
         this.logger = new Logger({
             loggerName: "falcon-frame",
-            ...loggerOpts
+            ...[opts?.loggerOpts || {}],
         });
+        this.opts = {
+            bodyLimit: "10m",
+            ...opts,
+        };
     }
     listen(port, callback, beforeHandleRequest) {
         const server = http.createServer(this.getApp(beforeHandleRequest));
@@ -38,9 +44,17 @@ export class FalconFrame extends Router {
             await handleRequest(req, res, this);
         };
     }
+    setVar(key, value) {
+        // @ts-ignore
+        this.vars[key] = value;
+    }
+    getVar(key) {
+        // @ts-ignore
+        return this.vars[key];
+    }
 }
 export default FalconFrame;
-export { FFRequest, FFResponse, PluginSystem, renderHTML, Router };
+export { FFResponse, PluginSystem, renderHTML, Router };
 export * as Plugins from "./plugins/index.js";
 export * as PluginsEngine from "./plugins.js";
 export * as Helpers from "./helpers.js";

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;
@@ -73,9 +75,9 @@ export function handleRequest(req, res, FF) {
     }
     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("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,7 +1,9 @@
 import http from "http";
 import { CookieOptions } from "./types.js";
+import FalconFrame from "./index.js";
 export declare class FFResponse extends http.ServerResponse {
     _ended: boolean;
+    FF: FalconFrame;
     /**
      * bind end for compatibility
     */

package/dist/res.js

@@ -2,8 +2,10 @@ import http from "http";
 import { getContentType } from "./helpers.js";
 import { createReadStream } from "fs";
 import { renderHTML } from "./render.js";
+import { resolve } from "path";
 export class FFResponse extends http.ServerResponse {
     _ended = false;
+    FF;
     /**
      * bind end for compatibility
     */
@@ -105,6 +107,9 @@ export class FFResponse extends http.ServerResponse {
      */
     render(templatePath, data = {}) {
         this.setHeader("Content-Type", "text/html");
+        if (this.FF.vars["views"] && !templatePath.endsWith(".html")) {
+            templatePath = resolve(this.FF.vars["views"] + "/" + templatePath + ".html");
+        }
         this.end(renderHTML(templatePath, data));
         return this;
     }

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.0.20",
+  "version": "0.1.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"