@wxn0brp/falcon-frame 0.5.7 → 0.5.9

package/README.md

@@ -97,7 +97,7 @@ app.post("/logout", (req, res) => {
 });
 
 // if no route matches
-app.all("*", (req, res) => {
+app.set404((req, res) => {
     res.status(404).json({ error: "Not found" });
 });
 

package/dist/compress.d.ts

@@ -1,4 +1,4 @@
 import { FFResponse } from "./res.js";
-import { FFRequest } from "./types.js";
+import { FFRequest, RouteHandler } from "./types.js";
 export declare function compression(req: FFRequest, res: FFResponse): void;
-export declare function compressionMiddleware(): (req: FFRequest, res: FFResponse, next: () => void) => void;
+export declare const compressionMiddleware: RouteHandler;

package/dist/compress.js

@@ -27,29 +27,54 @@ export function compression(req, res) {
     compressionStream.on("end", () => {
         originalEnd.call(res);
     });
+    compressionStream.on("error", (err) => {
+        if (!res.headersSent) {
+            res.statusCode = 500;
+            originalEnd.call(res);
+        }
+        else {
+            res.destroy(err);
+        }
+    });
+    res.on("close", () => {
+        compressionStream.destroy();
+    });
     // @ts-ignore
-    res.write = (chunk, encoding) => {
+    res.write = (...args) => {
+        const [chunk, encoding, cb] = args;
+        const callback = typeof encoding === "function" ? encoding : cb;
+        const enc = typeof encoding === "function" ? undefined : encoding;
         if (!res.headersSent) {
             res.writeHead(res.statusCode);
         }
-        return compressionStream.write(chunk, encoding);
+        return compressionStream.write(chunk, enc, callback);
     };
     // @ts-ignore
-    res.end = (chunk, encoding) => {
-        if (res.writableEnded) {
+    res.end = (...args) => {
+        if (res.writableEnded)
             return res;
+        const [chunk, encoding, cb] = args;
+        let finalChunk = chunk;
+        let finalCb = cb;
+        let finalEncoding = encoding;
+        if (typeof chunk === "function") {
+            finalCb = chunk;
+            finalChunk = undefined;
+        }
+        else if (typeof encoding === "function") {
+            finalCb = encoding;
+            finalEncoding = undefined;
         }
-        if (chunk) {
-            // @ts-ignore
-            res.write(chunk, encoding);
+        if (finalCb)
+            res.once("finish", finalCb);
+        if (finalChunk) {
+            res.write(finalChunk, finalEncoding);
         }
         compressionStream.end();
         return res;
     };
 }
-export function compressionMiddleware() {
-    return (req, res, next) => {
-        compression(req, res);
-        next();
-    };
-}
+export const compressionMiddleware = (req, res, next) => {
+    compression(req, res);
+    next();
+};

package/dist/index.d.ts

@@ -16,12 +16,14 @@ export declare class FalconFrame<Vars extends Record<string, any> = any> extends
     vars: Vars;
     opts: Opts;
     engines: Record<string, EngineCallback>;
+    _404: RouteHandler;
     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;
     setVar(key: keyof Vars, value: typeof this.vars[keyof Vars]): void;
+    set(key: keyof Vars, value: typeof this.vars[keyof Vars]): void;
     getVar(key: string): typeof this.vars[keyof Vars];
     /**
      * Sets the allowed origins for CORS.
@@ -38,6 +40,7 @@ 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>;
+    set404(handler: RouteHandler): void;
 }
 export default FalconFrame;
 export * as Helpers from "./helpers.js";

package/dist/index.js

@@ -12,6 +12,9 @@ export class FalconFrame extends Router {
     vars = {};
     opts = {};
     engines = {};
+    _404 = (req, res) => {
+        res.end("404: File had second thoughts");
+    };
     constructor(opts = {}) {
         super();
         const loggerOpts = opts?.loggerOpts || {};
@@ -89,6 +92,10 @@ export class FalconFrame extends Router {
         // @ts-ignore
         this.vars[key] = value;
     }
+    set(key, value) {
+        // @ts-ignore
+        this.vars[key] = value;
+    }
     getVar(key) {
         // @ts-ignore
         return this.vars[key];
@@ -112,6 +119,9 @@ export class FalconFrame extends Router {
     l(port) {
         return this.listen(+process.env.PORT || port, true);
     }
+    set404(handler) {
+        this._404 = handler;
+    }
 }
 export default FalconFrame;
 export * as Helpers from "./helpers.js";

package/dist/req.js

@@ -36,13 +36,16 @@ export function handleRequest(req, res, FF) {
     logger.debug("Matched middlewares: " +
         matchedMiddlewares.map((middleware) => middleware.path).join(", "));
     if (matchedMiddlewares.length === 0) {
-        res.status(404).end("404: File had second thoughts");
+        res.status(404);
+        FF._404(req, res);
         return;
     }
     let middlewareIndex = 0;
     async function next() {
         if (middlewareIndex >= matchedMiddlewares.length) {
-            return res.status(404).end("404: File had second thoughts");
+            res.status(404);
+            FF._404(req, res);
+            return;
         }
         const middleware = matchedMiddlewares[middlewareIndex++];
         logger.debug(`Executing middleware ${middlewareIndex} of ${matchedMiddlewares.length} matched for path [${middleware.path}]`);

package/package.json

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