@wxn0brp/falcon-frame 0.5.9 → 0.6.0

package/README.md

@@ -22,7 +22,7 @@ yarn add @wxn0brp/falcon-frame
 ## 🚦 Usage Example
 
 ```ts
-import FalconFrame from "@wxn0brp/falcon-frame";
+import FalconFrame, { validateBody } from "@wxn0brp/falcon-frame";
 const app = new FalconFrame();
 
 app.setOrigin("*");
@@ -67,22 +67,18 @@ app.post("/login", (req, res) => {
     res.status(401).json({ status: "fail", message: "Invalid credentials" });
 });
 
-app.post("/register", (req, res, next) => {
-    const { valid, validErrors } = req.valid({
+app.post(
+    "/register", 
+    validateBody({
         username: "required|string|min:3|max:20",
         password: "required|string|min:8",
-    });
-
-    if (!valid) {
-        return res.status(400).json({ status: "error", errors: validErrors });
+    }),
+    (req, res) => {
+        const { username, password } = req.body;
+        USERS[username] = password;
+        return { status: "success", message: "User registered successfully" };
     }
-
-    next();
-}, (req, res) => {
-    const { username, password } = req.body;
-    USERS[username] = password;
-    return { status: "success", message: "User registered successfully" };
-});
+);
 
 // Protected route
 app.get("/dashboard", requireAuth, (req, res) => {

package/dist/body-utils.d.ts

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

package/dist/body-utils.js

@@ -25,16 +25,18 @@ export function parseLimit(limit) {
 export function getContentType(req) {
     return req.headers["content-type"]?.split(";")[0].toLowerCase();
 }
-export function getRawBody(req, limit) {
+export function getRawBody(req, res, 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;
+                res.status(413);
+                res.FF._413(req, res);
                 req.destroy();
+                // @ts-ignore
+                error.cancel = true;
                 return reject(error);
             }
         });
@@ -53,13 +55,14 @@ export function getStandardBodyParser(type, parser, FF, opts) {
             return next();
         }
         try {
-            const body = await getRawBody(req, limit);
+            const body = await getRawBody(req, res, limit);
             req.body = await parser(body, req, FF);
+            next();
         }
         catch (err) {
+            if (err.cancel)
+                return;
             req.body = {};
-        }
-        finally {
             next();
         }
     };

package/dist/index.d.ts

@@ -3,7 +3,7 @@ import http from "http";
 import { renderHTML } from "./render.js";
 import { FFResponse } from "./res.js";
 import { Router } from "./router.js";
-import type { BeforeHandleRequest, EngineCallback, FFRequest, RouteHandler } from "./types.js";
+import type { BeforeHandleRequest, EngineCallback, ErrorHandler, FFRequest, RouteHandler, ValidationErrorFormatter } from "./types.js";
 export interface Opts {
     loggerOpts?: LoggerOptions;
     bodyLimit?: string;
@@ -16,7 +16,10 @@ export declare class FalconFrame<Vars extends Record<string, any> = any> extends
     vars: Vars;
     opts: Opts;
     engines: Record<string, EngineCallback>;
+    _400_formatter: ValidationErrorFormatter;
     _404: RouteHandler;
+    _413: RouteHandler;
+    _500: ErrorHandler;
     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>;
@@ -40,8 +43,12 @@ export declare class FalconFrame<Vars extends Record<string, any> = any> extends
      * @returns The server object returned by the listen method.
      */
     l(port: number): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    set400Formatter(formatter: ValidationErrorFormatter): void;
     set404(handler: RouteHandler): void;
+    set413(handler: RouteHandler): void;
+    set500(handler: ErrorHandler): void;
 }
 export default FalconFrame;
 export * as Helpers from "./helpers.js";
+export { validateBody } from "./valid.js";
 export { FFRequest, FFResponse, renderHTML, RouteHandler, Router };

package/dist/index.js

@@ -12,9 +12,22 @@ export class FalconFrame extends Router {
     vars = {};
     opts = {};
     engines = {};
+    _400_formatter = (err) => {
+        return {
+            err: true,
+            msg: "Bad request",
+            errors: err,
+        };
+    };
     _404 = (req, res) => {
         res.end("404: File had second thoughts");
     };
+    _413 = (req, res) => {
+        res.end("413: Cat is too fat");
+    };
+    _500 = (err, req, res) => {
+        res.end("500: The code had an existential crisis");
+    };
     constructor(opts = {}) {
         super();
         const loggerOpts = opts?.loggerOpts || {};
@@ -119,10 +132,20 @@ export class FalconFrame extends Router {
     l(port) {
         return this.listen(+process.env.PORT || port, true);
     }
+    set400Formatter(formatter) {
+        this._400_formatter = formatter;
+    }
     set404(handler) {
         this._404 = handler;
     }
+    set413(handler) {
+        this._413 = handler;
+    }
+    set500(handler) {
+        this._500 = handler;
+    }
 }
 export default FalconFrame;
 export * as Helpers from "./helpers.js";
+export { validateBody } from "./valid.js";
 export { FFResponse, renderHTML, Router };

package/dist/req.js

@@ -61,15 +61,24 @@ export function handleRequest(req, res, FF) {
             }
         }
         req.middleware = middleware;
-        const result = await middleware.middleware(req, res, next);
-        if (result && !res._ended) {
-            if (typeof result === "string") {
-                return res.end(result);
+        try {
+            const result = await middleware.middleware(req, res, next);
+            if (result && !res._ended) {
+                if (typeof result === "string") {
+                    return res.end(result);
+                }
+                else if (typeof result === "object") {
+                    if (result instanceof FFResponse)
+                        return res.end();
+                    return res.json(result);
+                }
             }
-            else if (typeof result === "object") {
-                if (result instanceof FFResponse)
-                    return res.end();
-                return res.json(result);
+        }
+        catch (err) {
+            logger.error(`Unhandled error in middleware for path [${middleware.path}]:`, err.stack || err);
+            if (!res.headersSent && !res.writableEnded) {
+                res.status(500);
+                FF._500(err, req, res);
             }
         }
     }

package/dist/types.d.ts

@@ -2,6 +2,7 @@ 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;
+export type ErrorHandler = (err: Error, req: FFRequest, res: FFResponse) => void | any;
 export type Method = "get" | "post" | "put" | "delete" | "all";
 export interface Params {
     [key: string]: string;
@@ -53,6 +54,7 @@ export interface ValidationResult {
         [key: string]: string[];
     };
 }
+export type ValidationErrorFormatter = (errors: ValidationResult["validErrors"]) => Record<string, any>;
 export type BeforeHandleRequest = (req: http.IncomingMessage, res: http.ServerResponse) => any;
 export interface StaticServeOptions {
     utf8?: boolean;

package/dist/valid.d.ts

@@ -1,2 +1,3 @@
-import { ValidationResult, ValidationSchema } from "./types.js";
+import { RouteHandler, ValidationResult, ValidationSchema } from "./types.js";
 export declare function validate(schema: ValidationSchema, data: any): ValidationResult;
+export declare function validateBody(schema: ValidationSchema): RouteHandler;

package/dist/valid.js

@@ -56,3 +56,13 @@ export function validate(schema, data) {
     }
     return { valid: isValid, validErrors: errors };
 }
+export function validateBody(schema) {
+    return (req, res, next) => {
+        const validationResult = req.valid(schema);
+        if (validationResult.valid) {
+            return next ? next() : undefined;
+        }
+        const errorResponse = res.FF._400_formatter(validationResult.validErrors);
+        res.status(400).json(errorResponse);
+    };
+}

package/package.json

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