@wxn0brp/falcon-frame 0.2.1 → 0.3.0

package/dist/body-utils.d.ts

@@ -0,0 +1,6 @@
+import FalconFrame from "./index.js";
+import type { FFRequest, ParseBodyFunction, RouteHandler, StandardBodyParserOptions } 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, limit: number): Promise<string>;
+export declare function getStandardBodyParser(type: string, parser: ParseBodyFunction, FF: FalconFrame, opts: StandardBodyParserOptions): RouteHandler;

package/dist/body-utils.js

@@ -0,0 +1,66 @@
+export function parseLimit(limit) {
+    if (!limit)
+        return 0;
+    if (typeof limit === "number")
+        return limit;
+    if (typeof limit !== "string")
+        return 0;
+    limit = limit.toLowerCase().replace("b", "");
+    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;
+    }
+}
+export function getContentType(req) {
+    return req.headers["content-type"]?.split(";")[0].toLowerCase();
+}
+export function getRawBody(req, limit) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+            if (limit && body.length > limit) {
+                const error = new Error("Payload Too Large");
+                // @ts-ignore
+                error.statusCode = 413;
+                req.destroy();
+                return reject(error);
+            }
+        });
+        req.on("end", () => {
+            resolve(body);
+        });
+        req.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+export function getStandardBodyParser(type, parser, FF, 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, limit);
+            req.body = await parser(body, req, FF);
+        }
+        catch (err) {
+            req.body = {};
+        }
+        finally {
+            next();
+        }
+    };
+}

package/dist/body.d.ts

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

package/dist/body.js

@@ -1,52 +1,8 @@
 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 {};
-    }
+import { getStandardBodyParser } from "./body-utils.js";
+export function json(FF, opts = {}) {
+    return getStandardBodyParser("application/json", (body) => JSON.parse(body), FF, opts);
 }
-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;
-    }
+export function urlencoded(FF, opts = {}) {
+    return getStandardBodyParser("application/x-www-form-urlencoded", (body) => querystring.parse(body), FF, opts);
 }

package/dist/index.d.ts

@@ -4,19 +4,22 @@ import { PluginSystem } from "./plugin.js";
 import { renderHTML } from "./render.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
-import type { BeforeHandleRequest, FFRequest, ParseBodyFunction, RouteHandler } from "./types.js";
+import type { BeforeHandleRequest, FFRequest, 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;
+    disableJsonParser?: boolean;
+    disableUrlencodedParser?: boolean;
 }
 export declare class FalconFrame<Vars extends Record<string, any> = any> extends Router {
     logger: Logger;
-    customParsers: Record<string, ParseBodyFunction>;
+    bodyParsers: RouteHandler[];
     vars: Vars;
     opts: Opts;
     engines: Record<string, EngineCallback>;
     constructor(opts?: Partial<Opts>);
+    addBodyParser(parser: RouteHandler): 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

@@ -6,22 +6,28 @@ import { renderHTML } from "./render.js";
 import { handleRequest } from "./req.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
+import { json, urlencoded } from "./body.js";
 export class FalconFrame extends Router {
     logger;
-    customParsers = {};
+    bodyParsers = [];
     vars = {};
     opts = {};
     engines = {};
     constructor(opts = {}) {
         super();
+        const loggerOpts = opts?.loggerOpts || {};
         this.logger = new Logger({
             loggerName: "falcon-frame",
-            ...[opts?.loggerOpts || {}],
+            ...loggerOpts,
         });
         this.opts = {
             bodyLimit: "10m",
             ...opts,
         };
+        if (!this.opts.disableJsonParser)
+            this.addBodyParser(json(this, { limit: this.opts.bodyLimit }));
+        if (!this.opts.disableUrlencodedParser)
+            this.addBodyParser(urlencoded(this, { limit: this.opts.bodyLimit }));
         this.engine(".html", (path, options, callback) => {
             try {
                 const content = renderHTML(path, options);
@@ -32,6 +38,10 @@ export class FalconFrame extends Router {
             }
         });
     }
+    addBodyParser(parser) {
+        this.bodyParsers.push(parser);
+        return this;
+    }
     listen(port, callback, beforeHandleRequest) {
         const server = http.createServer(this.getApp(beforeHandleRequest));
         if (typeof callback === "boolean") {

package/dist/req.js

@@ -3,7 +3,6 @@ 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;
@@ -71,6 +70,12 @@ export function handleRequest(req, res, FF) {
             }
         }
     }
+    const hasCustomParserEndpoint = matchedMiddlewares.some(middleware => middleware.customParser);
+    if (hasCustomParserEndpoint) {
+        req.body = {};
+        next();
+        return;
+    }
     if (req.method === "GET" ||
         req.method === "HEAD" ||
         req.method === "OPTIONS") {
@@ -78,12 +83,16 @@ export function handleRequest(req, res, FF) {
         next();
         return;
     }
-    let 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();
-    });
+    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);
+    }
+    nextBodyParser();
 }

package/dist/router.d.ts

@@ -12,4 +12,5 @@ export declare class Router {
     all(path: string, ...handlers: RouteHandler[]): this;
     static(apiPath: string, dirPath?: string, opts?: StaticServeOptions): this;
     sse(path: string, ...handlers: RouteHandler[]): this;
+    customParser(path: string, handler: RouteHandler, method?: Method): this;
 }

package/dist/router.js

@@ -63,4 +63,9 @@ export class Router {
         this.middlewares[index - 1].sse = true;
         return this;
     }
+    customParser(path, handler, method = "post") {
+        const index = this.addRoute(method, path, handler);
+        this.middlewares[index - 1].customParser = true;
+        return this;
+    }
 }

package/dist/types.d.ts

@@ -15,11 +15,10 @@ 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<Record<string, any>>;
+export interface StandardBodyParserOptions {
+    limit?: string | number;
 }
-export type ParseBodyFunction = (body: string, req: FFRequest, FF: FalconFrame) => Promise<ParseBody>;
 export declare class FFRequest extends http.IncomingMessage {
     path: string;
     query: Query;
@@ -36,6 +35,7 @@ export interface Middleware {
     use?: true;
     router?: Middleware[];
     sse?: true;
+    customParser?: true;
 }
 export interface CookieOptions {
     maxAge?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/falcon-frame",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",