@wxn0brp/falcon-frame 0.8.7 → 0.9.0

package/dist/body-utils.d.ts

@@ -1,6 +1,5 @@
-import { FFResponse } from "./index.js";
-import type { FFRequest, ParseBodyFunction, RouteHandler, StandardBodyParserOptions } from "./types.js";
+import { FFResponse } from "./res.js";
+import type { FFRequest } from "./types.js";
 export declare function parseLimit(limit: string | number): number;
 export declare function getContentType(req: FFRequest): string | undefined;
 export declare function getRawBody(req: FFRequest, res: FFResponse, limit: number): Promise<string>;
-export declare function getStandardBodyParser(type: string, parser: ParseBodyFunction, opts: StandardBodyParserOptions): RouteHandler;

package/dist/body-utils.js

@@ -46,23 +46,3 @@ export function getRawBody(req, res, limit) {
         });
     });
 }
-export function getStandardBodyParser(type, parser, opts) {
-    const limit = parseLimit(opts.limit || "100k");
-    return async (req, res, next) => {
-        if ((typeof req.body === "object" && Object.keys(req.body).length) ||
-            getContentType(req) !== type) {
-            return next();
-        }
-        try {
-            const body = await getRawBody(req, res, limit);
-            req.body = await parser(body, req, res);
-            next();
-        }
-        catch (err) {
-            if (res._ended)
-                return;
-            req.body = {};
-            next();
-        }
-    };
-}

package/dist/body.d.ts

@@ -1,3 +1,8 @@
-import { RouteHandler, StandardBodyParserOptions } from "./types.js";
-export declare function json(opts?: StandardBodyParserOptions): RouteHandler;
-export declare function urlencoded(opts?: StandardBodyParserOptions): RouteHandler;
+import { ParseBodyFunction } from "./types.js";
+export declare const json: ParseBodyFunction;
+export declare const urlencoded: ParseBodyFunction;
+export declare const yaml: ParseBodyFunction;
+export declare const toml: ParseBodyFunction;
+export declare const json5: ParseBodyFunction;
+export declare const xml: ParseBodyFunction;
+export declare const text: ParseBodyFunction;

package/dist/body.js

@@ -1,8 +1,10 @@
 import querystring from "querystring";
-import { getStandardBodyParser } from "./body-utils.js";
-export function json(opts = {}) {
-    return getStandardBodyParser("application/json", body => JSON.parse(body), opts);
-}
-export function urlencoded(opts = {}) {
-    return getStandardBodyParser("application/x-www-form-urlencoded", body => querystring.parse(body), opts);
-}
+export const json = body => JSON.parse(body);
+export const urlencoded = body => querystring.parse(body);
+export const yaml = body => Bun.YAML.parse(body);
+export const toml = body => Bun.TOML.parse(body);
+export const json5 = body => Bun.JSON5.parse(body);
+export const xml = body => new DOMParser().parseFromString(body, "text/xml");
+export const text = body => ({
+    data: body,
+});

package/dist/debug.js

@@ -24,14 +24,14 @@ export function createDebug(opts = {}) {
         return isHostAllowed(req) && checkAuth(req);
     }
     const router = new Router();
-    router.get(url, (req, res, next) => {
+    router.get(url, (req, res) => {
         if (!isAllowed(req))
-            return next();
+            return req.FF._404(req, res);
         res.sendFile(join(import.meta.dirname, "debug.html"));
     });
     const sse = router.sse(url + "/sse", (req, res, next) => {
         if (!isAllowed(req))
-            return req.FF._413(req, res);
+            return req.FF._404(req, res);
         next();
     }, () => { });
     router.use("/", (req, res, next) => {

package/dist/helpers.d.ts

@@ -1,4 +1,5 @@
-import { Cookies } from "./types.js";
+import { Cookies, FFRequest } from "./types.js";
 export declare function parseCookies(cookieHeader: string): Cookies;
+export declare function getIP(req: FFRequest): string;
 export declare function getContentType(filePath: string, utf8?: boolean): string;
 export declare const ensureLeadingDot: (str: string) => string;

package/dist/helpers.js

@@ -8,11 +8,24 @@ export function parseCookies(cookieHeader) {
     });
     return cookies;
 }
+export function getIP(req) {
+    const forwarded = req.headers["x-forwarded-for"];
+    if (forwarded) {
+        return (typeof forwarded === "string" ? forwarded : forwarded[0])
+            .split(",")[0]
+            .trim();
+    }
+    return req.socket.remoteAddress || "";
+}
 const mimeTypes = {
     ".html": "text/html",
     ".css": "text/css",
     ".js": "application/javascript",
     ".json": "application/json",
+    ".json5": "application/json5",
+    ".yaml": "application/yaml",
+    ".yml": "application/yaml",
+    ".toml": "application/toml",
     ".png": "image/png",
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",

package/dist/index.d.ts

@@ -3,10 +3,10 @@ import http from "http";
 import { renderHTML } from "./render.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
-import type { BeforeHandleRequest, CombinedVars, EngineCallback, ErrorHandler, FFOpts, FFRequest, RouteHandler, ValidationErrorFormatter } from "./types.js";
+import type { BeforeHandleRequest, BodyParserEntry, CombinedVars, EngineCallback, ErrorHandler, FFOpts, FFRequest, ParseBodyFunction, RouteHandler, StandardBodyParserOptions, ValidationErrorFormatter } from "./types.js";
 export declare class FalconFrame<Vars extends Record<string, any> = {}> extends Router {
     logger: Logger;
-    bodyParsers: RouteHandler[];
+    bodyParsers: Record<string, BodyParserEntry>;
     vars: CombinedVars<Vars>;
     opts: FFOpts;
     engines: Record<string, EngineCallback>;
@@ -15,7 +15,7 @@ export declare class FalconFrame<Vars extends Record<string, any> = {}> extends
     _413: RouteHandler;
     _500: ErrorHandler;
     constructor(opts?: Partial<FFOpts>);
-    addBodyParser(parser: RouteHandler): this;
+    addBodyParser(contentType: string, parser: ParseBodyFunction, opts?: StandardBodyParserOptions): this;
     listen(port: number | string, 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;

package/dist/index.js

@@ -1,6 +1,7 @@
 import { Logger } from "@wxn0brp/lucerna-log";
 import http from "http";
-import { json, urlencoded } from "./body.js";
+import * as bodyParser from "./body.js";
+import { parseLimit } from "./body-utils.js";
 import { createCORS } from "./cors.js";
 import { renderHTML } from "./render.js";
 import { handleRequest } from "./req.js";
@@ -8,7 +9,7 @@ import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
 export class FalconFrame extends Router {
     logger;
-    bodyParsers = [];
+    bodyParsers = {};
     vars = {};
     opts = {};
     engines = {};
@@ -39,14 +40,50 @@ export class FalconFrame extends Router {
             bodyLimit: "10m",
             ...opts,
         };
-        if (!this.opts.disableJsonParser)
-            this.addBodyParser(json({
-                limit: this.opts.bodyLimit,
-            }));
-        if (!this.opts.disableUrlencodedParser)
-            this.addBodyParser(urlencoded({
-                limit: this.opts.bodyLimit,
-            }));
+        const dp = this.opts.disableParser || {};
+        const isBun = !!globalThis.Bun;
+        const bunOnly = new Set([
+            "json5",
+            "yaml",
+            "toml",
+        ]);
+        const parsers = {
+            json: {
+                fn: bodyParser.json,
+                ct: "application/json",
+            },
+            urlencoded: {
+                fn: bodyParser.urlencoded,
+                ct: "application/x-www-form-urlencoded",
+            },
+            json5: {
+                fn: bodyParser.json5,
+                ct: "application/json5",
+            },
+            yaml: {
+                fn: bodyParser.yaml,
+                ct: "application/yaml",
+            },
+            toml: {
+                fn: bodyParser.toml,
+                ct: "application/toml",
+            },
+            xml: {
+                fn: bodyParser.xml,
+                ct: "application/xml",
+            },
+            text: {
+                fn: bodyParser.text,
+                ct: "text/plain",
+            },
+        };
+        for (const [key, { fn, ct }] of Object.entries(parsers)) {
+            if (dp[key])
+                continue;
+            if (bunOnly.has(key) && !isBun)
+                continue;
+            this.addBodyParser(ct, fn);
+        }
         this.engine(".html", (path, data, callback, FF) => {
             try {
                 const content = renderHTML({
@@ -61,8 +98,11 @@ export class FalconFrame extends Router {
             }
         });
     }
-    addBodyParser(parser) {
-        this.bodyParsers.push(parser);
+    addBodyParser(contentType, parser, opts = {}) {
+        this.bodyParsers[contentType] = {
+            parse: parser,
+            limit: parseLimit(opts.limit || this.opts.bodyLimit || "10m"),
+        };
         return this;
     }
     listen(port, callback, beforeHandleRequest) {

package/dist/req.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "crypto";
 import { URL } from "url";
-import { parseCookies } from "./helpers.js";
+import { getContentType, getRawBody } from "./body-utils.js";
+import { getIP, parseCookies } from "./helpers.js";
 import { getMiddlewares, matchMiddleware } from "./middleware.js";
 import { FFResponse } from "./res.js";
 import { validate } from "./valid.js";
@@ -29,12 +30,20 @@ export function handleRequest(req, res, FF, reRoute = false) {
         return;
     }
     req.cookies = parseCookies(req.headers.cookie || "");
+    req.ip = getIP(req);
     req.params = {};
-    req.valid = (schema) => validate(schema, req.body);
+    req.valid = (schema, regexRules) => validate({
+        schema,
+        data: req.body,
+        regexRules,
+        isBodyParsed: req.isBodyParsed,
+    });
     req.reRoute = fn => {
         fn(req);
         handleRequest(req, res, FF, true);
     };
+    req.header = (name) => req.headers[name.toLowerCase()] || "";
+    req.isBodyParsed = false;
     if (FF.opts.xRequestId !== "disable") {
         if (req.headers["x-request-id"]) {
             req.id = req.headers["x-request-id"];
@@ -122,15 +131,29 @@ export function handleRequest(req, res, FF, reRoute = false) {
         return;
     }
     req.body = {};
-    let bodyParserIndex = 0;
-    function nextBodyParser() {
-        if (bodyParserIndex >= FF.bodyParsers.length) {
-            logger.debug("No more body parsers. Executing middlewares");
-            return next();
-        }
-        logger.debug(`Executing body parser ${bodyParserIndex} of ${FF.bodyParsers.length}`);
-        const bodyParser = FF.bodyParsers[bodyParserIndex++];
-        bodyParser(req, res, nextBodyParser);
+    const ct = getContentType(req) || "application/json";
+    const entry = FF.bodyParsers[ct];
+    if (!entry) {
+        logger.debug("No body parser found for content-type. Executing middlewares");
+        next();
+        return;
     }
-    nextBodyParser();
+    logger.debug(`Executing body parser for content-type: ${ct}`);
+    getRawBody(req, res, entry.limit)
+        .then(async (rawBody) => {
+        try {
+            req.body = (await entry.parse(rawBody, req, res)) ?? {};
+            req.isBodyParsed = true;
+        }
+        catch (err) {
+            if (!res._ended)
+                req.body = {};
+        }
+        next();
+    })
+        .catch(() => {
+        if (!res._ended)
+            req.body = {};
+        next();
+    });
 }

package/dist/res.d.ts

@@ -31,6 +31,7 @@ export declare class FFResponse extends http.ServerResponse {
      * @param options The options for the cookie
      */
     cookie(name: string, value: string, options?: CookieOptions): this;
+    clearCookie(name: string, options?: CookieOptions): this;
     /**
      * Set the status code for the response
      * @param code The status code to set

package/dist/res.js

@@ -44,7 +44,7 @@ export class FFResponse extends http.ServerResponse {
      */
     cookie(name, value, options = {}) {
         let cookie = `${name}=${encodeURIComponent(value)}`;
-        if (options.maxAge)
+        if (options.maxAge !== undefined)
             cookie += `; Max-Age=${options.maxAge}`;
         if (options.path)
             cookie += `; Path=${options.path}`;
@@ -57,6 +57,12 @@ export class FFResponse extends http.ServerResponse {
         this.setHeader("Set-Cookie", cookie);
         return this;
     }
+    clearCookie(name, options = {}) {
+        return this.cookie(name, "", {
+            ...options,
+            maxAge: 0,
+        });
+    }
     /**
      * Set the status code for the response
      * @param code The status code to set

package/dist/types.d.ts

@@ -17,7 +17,11 @@ export interface Query {
 export interface Body {
     [key: string]: any;
 }
-export type ParseBodyFunction = (body: string, req: FFRequest, res: FFResponse) => Promise<Record<string, any>>;
+export type ParseBodyFunction = (body: string, req: FFRequest, res: FFResponse) => Record<string, any> | Promise<Record<string, any>>;
+export interface BodyParserEntry {
+    parse: ParseBodyFunction;
+    limit: number;
+}
 export interface StandardBodyParserOptions {
     limit?: string | number;
 }
@@ -28,11 +32,14 @@ export declare class FFRequest extends http.IncomingMessage {
     params: Params;
     cookies: Cookies;
     body: Body;
-    valid: (schema: ValidationSchema) => ValidationResult;
+    ip: string;
+    header: (name: string) => string;
+    valid: (schema: ValidationSchema, regexRules?: Record<string, RegExp | string>) => ValidationResult;
     middleware: Middleware;
     id?: string;
     sseId?: string;
     reRoute: (fn: (req: FFRequest) => void) => void;
+    isBodyParsed: boolean;
     _compression?: true;
 }
 export interface Middleware {
@@ -81,8 +88,15 @@ export interface RenderOptions {
 export interface FFOpts {
     loggerOpts?: LoggerOptions;
     bodyLimit?: string;
-    disableJsonParser?: boolean;
-    disableUrlencodedParser?: boolean;
+    disableParser?: {
+        json?: boolean;
+        urlencoded?: boolean;
+        json5?: boolean;
+        yaml?: boolean;
+        toml?: boolean;
+        xml?: boolean;
+        text?: boolean;
+    };
     xRequestId?: "auto" | "disable" | "manual";
 }
 export type FFVars = {

package/dist/types.js

@@ -6,10 +6,13 @@ export class FFRequest extends http.IncomingMessage {
     params;
     cookies;
     body;
+    ip;
+    header;
     valid;
     middleware;
     id;
     sseId;
     reRoute;
+    isBodyParsed;
     _compression;
 }

package/dist/valid.d.ts

@@ -1,3 +1,9 @@
 import { RouteHandler, ValidationResult, ValidationSchema } from "./types.js";
-export declare function validate(schema: ValidationSchema, data: any): ValidationResult;
-export declare function validateBody(schema: ValidationSchema): RouteHandler;
+export interface ValidateBody {
+    schema: ValidationSchema;
+    data: any;
+    regexRules: Record<string, RegExp | string>;
+    isBodyParsed: boolean;
+}
+export declare function validate(opts: ValidateBody): ValidationResult;
+export declare function validateBody(schema: ValidationSchema, regexRules?: Record<string, RegExp | string>): RouteHandler;

package/dist/valid.js

@@ -1,28 +1,83 @@
-export function validate(schema, data) {
+const optionalKeys = new Set([
+    "nullable",
+    "optional",
+    "opt",
+]);
+export function validate(opts) {
+    if (!opts.isBodyParsed) {
+        return {
+            valid: false,
+            validErrors: {
+                _body: [
+                    "Request body could not be parsed. Check Content-Type header and body format.",
+                ],
+            },
+        };
+    }
+    const { schema, data, regexRules } = opts;
     const errors = {};
     let isValid = true;
     for (const key in schema) {
         const rules = schema[key].split("|");
         const value = data[key];
         const fieldErrors = [];
+        const isOptional = rules.some(r => optionalKeys.has(r));
+        if (isOptional && (value === null || value === undefined)) {
+            continue;
+        }
         for (const rule of rules) {
             const [ruleName, param] = rule.split(":");
             switch (ruleName) {
                 case "required":
+                case "r":
                     if (!value && value !== 0) {
                         fieldErrors.push(`${key} is required`);
                     }
                     break;
                 case "string":
+                case "str":
+                case "s":
                     if (typeof value !== "string") {
                         fieldErrors.push(`${key} must be a string`);
                     }
                     break;
                 case "number":
+                case "num":
+                case "n":
                     if (typeof value !== "number") {
                         fieldErrors.push(`${key} must be a number`);
                     }
                     break;
+                case "integer":
+                case "int":
+                case "i":
+                    if (!Number.isInteger(value)) {
+                        fieldErrors.push(`${key} must be an integer`);
+                    }
+                    break;
+                case "boolean":
+                case "bool":
+                case "b":
+                    if (typeof value !== "boolean") {
+                        fieldErrors.push(`${key} must be a boolean`);
+                    }
+                    break;
+                case "array":
+                case "arr":
+                case "a":
+                    if (!Array.isArray(value)) {
+                        fieldErrors.push(`${key} must be an array`);
+                    }
+                    break;
+                case "object":
+                case "obj":
+                case "o":
+                    if (typeof value !== "object" ||
+                        Array.isArray(value) ||
+                        value === null) {
+                        fieldErrors.push(`${key} must be an object`);
+                    }
+                    break;
                 case "min":
                     if (typeof value === "string" && value.length < parseInt(param)) {
                         fieldErrors.push(`${key} must be at least ${param} characters long`);
@@ -30,6 +85,9 @@ export function validate(schema, data) {
                     if (typeof value === "number" && value < parseInt(param)) {
                         fieldErrors.push(`${key} must be at least ${param}`);
                     }
+                    if (Array.isArray(value) && value.length < parseInt(param)) {
+                        fieldErrors.push(`${key} must have at least ${param} items`);
+                    }
                     break;
                 case "max":
                     if (typeof value === "string" && value.length > parseInt(param)) {
@@ -38,7 +96,36 @@ export function validate(schema, data) {
                     if (typeof value === "number" && value > parseInt(param)) {
                         fieldErrors.push(`${key} must not exceed ${param}`);
                     }
+                    if (Array.isArray(value) && value.length > parseInt(param)) {
+                        fieldErrors.push(`${key} must not exceed ${param} items`);
+                    }
+                    break;
+                case "between": {
+                    const [min, max] = param.split(",");
+                    if (typeof value === "number" &&
+                        (value < parseInt(min) || value > parseInt(max))) {
+                        fieldErrors.push(`${key} must be between ${min} and ${max}`);
+                    }
+                    if (typeof value === "string" &&
+                        (value.length < parseInt(min) || value.length > parseInt(max))) {
+                        fieldErrors.push(`${key} must be between ${min} and ${max} characters`);
+                    }
                     break;
+                }
+                case "in": {
+                    const values = param.split(",");
+                    if (!values.includes(String(value))) {
+                        fieldErrors.push(`${key} must be one of: ${values.join(", ")}`);
+                    }
+                    break;
+                }
+                case "not_in": {
+                    const values = param.split(",");
+                    if (values.includes(String(value))) {
+                        fieldErrors.push(`${key} must not be one of: ${values.join(", ")}`);
+                    }
+                    break;
+                }
                 case "email": {
                     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
                     if (!emailRegex.test(value)) {
@@ -46,6 +133,29 @@ export function validate(schema, data) {
                     }
                     break;
                 }
+                case "same": {
+                    const otherValue = data[param];
+                    if (value !== otherValue) {
+                        fieldErrors.push(`${key} must be the same as ${param}`);
+                    }
+                    break;
+                }
+                case "diff":
+                case "different": {
+                    const otherValue = data[param];
+                    if (value === otherValue) {
+                        fieldErrors.push(`${key} must be different from ${param}`);
+                    }
+                    break;
+                }
+            }
+        }
+        if (regexRules && regexRules[key] !== undefined) {
+            const regex = regexRules[key] instanceof RegExp
+                ? regexRules[key]
+                : new RegExp(regexRules[key]);
+            if (!regex.test(value)) {
+                fieldErrors.push(`${key} format is invalid`);
             }
         }
         if (fieldErrors.length > 0) {
@@ -58,13 +168,14 @@ export function validate(schema, data) {
         validErrors: errors,
     };
 }
-export function validateBody(schema) {
+export function validateBody(schema, regexRules) {
     return (req, res, next) => {
-        const validationResult = req.valid(schema);
-        if (validationResult.valid) {
-            return next ? next() : undefined;
+        const validationResult = req.valid(schema, regexRules);
+        if (!validationResult.valid) {
+            const errorResponse = res.FF._400_formatter(validationResult.validErrors);
+            res.status(400).json(errorResponse);
+            return;
         }
-        const errorResponse = res.FF._400_formatter(validationResult.validErrors);
-        res.status(400).json(errorResponse);
+        next();
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.8.7",
+  "version": "0.9.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -23,7 +23,7 @@
     "middleware-chain"
   ],
   "devDependencies": {
-    "@types/node": "*",
+    "@types/bun": "*",
     "@wxn0brp/biome": "*",
     "tsc-alias": "*",
     "typescript": "^7"