@wxn0brp/falcon-frame 0.2.1 → 0.4.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/plugin.d.ts

@@ -11,6 +11,15 @@ export interface PluginOptions {
     after?: PluginId | PluginId[];
     optional?: boolean;
 }
+/**
+ * @deprecated
+ * The `PluginSystem` class is deprecated and should not be used in new projects.
+ *
+ * ⚠️ Notes:
+ * - It may be refactored in the future, but any refactor will introduce breaking changes.
+ * - If your system currently relies on it and it works, you may continue using it.
+ * - If it does not work in your setup, it is recommended to skip it or wait for an update.
+ */
 export declare class PluginSystem {
     private plugins;
     private executionOrder;

package/dist/plugin.js

@@ -1,3 +1,12 @@
+/**
+ * @deprecated
+ * The `PluginSystem` class is deprecated and should not be used in new projects.
+ *
+ * ⚠️ Notes:
+ * - It may be refactored in the future, but any refactor will introduce breaking changes.
+ * - If your system currently relies on it and it works, you may continue using it.
+ * - If it does not work in your setup, it is recommended to skip it or wait for an update.
+ */
 export class PluginSystem {
     plugins = [];
     executionOrder = [];

package/dist/render.d.ts

@@ -1,5 +1,6 @@
+import FalconFrame from "./index.js";
 interface RenderData {
     [key: string]: string;
 }
-export declare function renderHTML(templatePath: string, data: RenderData, renderedPaths?: string[]): string;
+export declare function renderHTML(templatePath: string, data: RenderData, renderedPaths?: string[], FF?: FalconFrame): string;
 export {};

package/dist/render.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-export function renderHTML(templatePath, data, renderedPaths = []) {
+export function renderHTML(templatePath, data, renderedPaths = [], FF) {
     try {
         const realPath = path.resolve(templatePath);
         if (renderedPaths.includes(realPath)) {
@@ -17,6 +17,17 @@ export function renderHTML(templatePath, data, renderedPaths = []) {
                 realPath,
             ]);
         });
+        // Layout
+        if (FF && FF.vars["layout"]) {
+            const hasHtmlStructure = /<\s*html|<\s*body/i.test(template);
+            const forceLayout = /<!--\s*force-layout\s*-->/.test(template);
+            const forceNoLayout = /<!--\s*force-no-layout\s*-->/.test(template);
+            if (hasHtmlStructure && !forceLayout)
+                return template;
+            if (!hasHtmlStructure && forceNoLayout)
+                return template;
+            return renderHTML(FF.vars["layout"], { ...data, body: template }, [...renderedPaths, realPath]);
+        }
         return template;
     }
     catch (error) {

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,19 +70,31 @@ export function handleRequest(req, res, FF) {
             }
         }
     }
+    const hasCustomParserEndpoint = matchedMiddlewares.some(middleware => middleware.customParser);
+    if (hasCustomParserEndpoint) {
+        logger.debug("Executing custom parser endpoint");
+        req.body = {};
+        next();
+        return;
+    }
     if (req.method === "GET" ||
         req.method === "HEAD" ||
         req.method === "OPTIONS") {
+        logger.debug("Method does not require body. Executing middlewares");
         req.body = {};
         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

@@ -1,5 +1,6 @@
 import { PluginSystem } from "./plugin.js";
 import { Method, Middleware, RouteHandler, StaticServeOptions } from "./types.js";
+import { SSEManager } from "./sse.js";
 export type MiddlewareFn = RouteHandler | Router | PluginSystem;
 export declare class Router {
     middlewares: Middleware[];
@@ -11,5 +12,6 @@ export declare class Router {
     delete(path: string, ...handlers: RouteHandler[]): this;
     all(path: string, ...handlers: RouteHandler[]): this;
     static(apiPath: string, dirPath?: string, opts?: StaticServeOptions): this;
-    sse(path: string, ...handlers: RouteHandler[]): this;
+    sse(path: string, ...handlers: RouteHandler[]): SSEManager;
+    customParser(path: string, handler: RouteHandler, method?: Method): this;
 }

package/dist/router.js

@@ -1,5 +1,6 @@
 import { handleStaticFiles } from "./helpers.js";
 import { PluginSystem } from "./plugin.js";
+import { SSEManager } from "./sse.js";
 export class Router {
     middlewares = [];
     addRoute(method, path, ...handlers) {
@@ -59,8 +60,15 @@ export class Router {
         return this;
     }
     sse(path, ...handlers) {
-        const index = this.addRoute("get", path, ...handlers);
-        this.middlewares[index - 1].sse = true;
+        const lastHandler = handlers.pop() || (() => { });
+        const manager = new SSEManager();
+        handlers.push(manager.getMiddleware(lastHandler));
+        this.addRoute("get", path, ...handlers);
+        return manager;
+    }
+    customParser(path, handler, method = "post") {
+        const index = this.addRoute(method, path, handler);
+        this.middlewares[index - 1].customParser = true;
         return this;
     }
 }

package/dist/sse.d.ts

@@ -0,0 +1,13 @@
+import type { FFRequest, RouteHandler } from "./types.js";
+import { FFResponse } from "./res.js";
+export declare class SSEManager {
+    private clients;
+    getMiddleware(lastHandler?: RouteHandler): RouteHandler;
+    getClients(): Map<string, {
+        req: FFRequest;
+        res: FFResponse;
+    }>;
+    sendAll(data: any): void;
+    sendTo(id: string, data: any): void;
+    disconnect(id: string): void;
+}

package/dist/sse.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "crypto";
+export class SSEManager {
+    clients = new Map();
+    getMiddleware(lastHandler) {
+        return (req, res, next) => {
+            res.sseInit();
+            const id = randomUUID();
+            this.clients.set(id, { req, res });
+            req.on("close", () => {
+                this.clients.delete(id);
+            });
+            req.sseId = id;
+            lastHandler?.(req, res, next);
+        };
+    }
+    getClients() {
+        return this.clients;
+    }
+    sendAll(data) {
+        for (const { res } of this.clients.values()) {
+            res.sseSend(data);
+        }
+    }
+    sendTo(id, data) {
+        const client = this.clients.get(id);
+        if (client) {
+            client.res.sseSend(data);
+        }
+    }
+    disconnect(id) {
+        const client = this.clients.get(id);
+        if (client) {
+            client.res.end();
+            this.clients.delete(id);
+        }
+    }
+}

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;
@@ -28,6 +27,7 @@ export declare class FFRequest extends http.IncomingMessage {
     body: Body;
     valid: (schema: ValidationSchema) => ValidationResult;
     middleware: Middleware;
+    sseId?: string;
 }
 export interface Middleware {
     path: string;
@@ -35,7 +35,7 @@ export interface Middleware {
     middleware: RouteHandler;
     use?: true;
     router?: Middleware[];
-    sse?: true;
+    customParser?: true;
 }
 export interface CookieOptions {
     maxAge?: number;

package/dist/types.js

@@ -7,4 +7,5 @@ export class FFRequest extends http.IncomingMessage {
     body;
     valid;
     middleware;
+    sseId;
 }

package/package.json

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