@wxn0brp/falcon-frame 0.0.16 → 0.0.18

package/dist/helpers.js

@@ -76,6 +76,7 @@ export function handleStaticFiles(dirPath, utf8 = true) {
             if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
                 if (!req.path.endsWith("/")) {
                     res.redirect(req.path + "/");
+                    return true;
                 }
                 res.ct(getContentType(indexPath, utf8));
                 fs.createReadStream(indexPath).pipe(res);

package/dist/middleware.d.ts

@@ -0,0 +1,3 @@
+import { Middleware } from "./types.js";
+export declare function matchMiddleware(url: string, middlewares: Middleware[]): Middleware[];
+export declare function getMiddlewares(middlewares: Middleware[], matchUrl: string, basePath?: string): Middleware[];

package/dist/middleware.js

@@ -0,0 +1,69 @@
+export function matchMiddleware(url, middlewares) {
+    const matchedMiddlewares = [];
+    url = url.replace(/\/$/, "");
+    for (const middleware of middlewares) {
+        const cleanedMiddleware = middleware.path.replace(/\/$/, "");
+        if (middleware.use) {
+            if (url.startsWith(cleanedMiddleware)) {
+                matchedMiddlewares.push(middleware);
+            }
+        }
+        else if (cleanedMiddleware === "*") {
+            matchedMiddlewares.push(middleware);
+        }
+        else if (cleanedMiddleware.endsWith("/*")) {
+            const prefix = cleanedMiddleware.slice(0, -2);
+            if (url.startsWith(prefix)) {
+                matchedMiddlewares.push(middleware);
+            }
+        }
+        else if (cleanedMiddleware.includes(":")) {
+            const middlewareParts = cleanedMiddleware.split("/");
+            const urlParts = url.split("/");
+            if (middlewareParts.length !== urlParts.length) {
+                continue;
+            }
+            let matches = true;
+            for (let i = 0; i < middlewareParts.length; i++) {
+                if (middlewareParts[i].startsWith(":")) {
+                    continue;
+                }
+                else if (middlewareParts[i] !== urlParts[i]) {
+                    matches = false;
+                    break;
+                }
+            }
+            if (matches) {
+                matchedMiddlewares.push(middleware);
+            }
+        }
+        else {
+            if (url === cleanedMiddleware) {
+                matchedMiddlewares.push(middleware);
+            }
+        }
+    }
+    return matchedMiddlewares;
+}
+export function getMiddlewares(middlewares, matchUrl, basePath = "") {
+    const result = [];
+    for (const middleware of middlewares) {
+        const midPath = (middleware.path || "").replace(/\/+$/, "");
+        const fullPath = (basePath + "/" + midPath).replace(/\/+/g, "/");
+        const matches = matchUrl === fullPath ||
+            (middleware.use && matchUrl.startsWith(fullPath)) ||
+            fullPath.includes(":") ||
+            fullPath.includes("*") ||
+            matchUrl.startsWith(fullPath + "/");
+        if (!matches)
+            continue;
+        if (middleware.router) {
+            const nested = getMiddlewares(middleware.router, matchUrl, fullPath);
+            result.push(...nested);
+        }
+        else {
+            result.push({ ...middleware, path: fullPath });
+        }
+    }
+    return result;
+}

package/dist/render.js

@@ -1,6 +1,8 @@
 import fs from "fs";
 import path from "path";
 export function renderHTML(templatePath, data) {
+    if (!fs.existsSync(templatePath))
+        return "Template not found";
     let template = fs.readFileSync(templatePath, "utf8");
     // Inserting data, e.g. {{name}}
     template = template.replace(/{{(.*?)}}/g, (_, key) => data[key.trim()] || "");

package/dist/req.js

@@ -2,6 +2,7 @@ import { URL } from "url";
 import { parseBody, parseCookies } from "./helpers.js";
 import { FFResponse } from "./res.js";
 import { validate } from "./valid.js";
+import { getMiddlewares, matchMiddleware } from "./middleware.js";
 export function handleRequest(req, res, FF) {
     Object.setPrototypeOf(res, FFResponse.prototype);
     const originalEnd = res.end;
@@ -26,117 +27,56 @@ export function handleRequest(req, res, FF) {
     req.params = {};
     req.valid = (schema) => validate(schema, req.body);
     logger.info(`Incoming request: ${req.method} ${req.url}`);
-    const middlewares = getMiddlewares(FF.middlewares, (req.url + "/").replace(/\/+/g, "/"));
-    let body = "";
-    req.on("data", chunk => (body += chunk.toString()));
-    req.on("end", () => {
-        const contentType = req.headers["content-type"] || "";
-        req.body = parseBody(contentType, body);
-        logger.debug(`Request body: ${JSON.stringify(req.body)}`);
-        const matchedTypeMiddlewares = middlewares.filter(middleware => middleware.method === req.method.toLocaleLowerCase() || middleware.method === "all");
-        const matchedMiddlewares = matchMiddleware(req.path, matchedTypeMiddlewares);
-        if (matchedMiddlewares.length === 0) {
-            return res.status(404).end("404: File had second thoughts.");
-        }
-        logger.debug("Matched middlewares: " + matchedMiddlewares.map(middleware => middleware.path).join(", "));
-        let middlewareIndex = 0;
-        const next = async () => {
-            if (middlewareIndex >= matchedMiddlewares.length) {
-                return res.status(404).end("404: File had second thoughts");
-            }
-            const middleware = matchedMiddlewares[middlewareIndex++];
-            logger.debug(`Executing middleware ${middlewareIndex} of ${matchedMiddlewares.length} matched for path [${middleware.path}]`);
-            if (middleware.path.includes(":")) {
-                const middlewareParts = middleware.path.split("/");
-                const reqPathParts = req.path.split("/");
-                req.params = {};
-                for (let i = 0; i < middlewareParts.length; i++) {
-                    if (middlewareParts[i].startsWith(":")) {
-                        const paramName = middlewareParts[i].slice(1);
-                        req.params[paramName] = reqPathParts[i];
-                    }
-                }
-            }
-            req.middleware = middleware;
-            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") {
-                    return res.json(result);
-                }
-            }
-        };
-        next();
-    });
-}
-function matchMiddleware(url, middlewares) {
-    const matchedMiddlewares = [];
-    url = url.replace(/\/$/, "");
-    for (const middleware of middlewares) {
-        const cleanedMiddleware = middleware.path.replace(/\/$/, "");
-        if (middleware.use) {
-            if (url.startsWith(cleanedMiddleware)) {
-                matchedMiddlewares.push(middleware);
-            }
-        }
-        else if (cleanedMiddleware === "*") {
-            matchedMiddlewares.push(middleware);
-        }
-        else if (cleanedMiddleware.endsWith("/*")) {
-            const prefix = cleanedMiddleware.slice(0, -2);
-            if (url.startsWith(prefix)) {
-                matchedMiddlewares.push(middleware);
-            }
+    const middlewaresPath = req.path + "/";
+    const middlewares = getMiddlewares(FF.middlewares, middlewaresPath.replace(/\/+/g, "/"));
+    const matchedTypeMiddlewares = middlewares.filter(middleware => middleware.method === req.method.toLowerCase() || middleware.method === "all");
+    const matchedMiddlewares = matchMiddleware(req.path, matchedTypeMiddlewares);
+    logger.debug("Matched middlewares: " + matchedMiddlewares.map(middleware => middleware.path).join(", "));
+    if (matchedMiddlewares.length === 0) {
+        res.status(404).end("404: File had second thoughts");
+        return;
+    }
+    let middlewareIndex = 0;
+    async function next() {
+        if (middlewareIndex >= matchedMiddlewares.length) {
+            return res.status(404).end("404: File had second thoughts");
         }
-        else if (cleanedMiddleware.includes(":")) {
-            const middlewareParts = cleanedMiddleware.split("/");
-            const urlParts = url.split("/");
-            if (middlewareParts.length !== urlParts.length) {
-                continue;
-            }
-            let matches = true;
+        const middleware = matchedMiddlewares[middlewareIndex++];
+        logger.debug(`Executing middleware ${middlewareIndex} of ${matchedMiddlewares.length} matched for path [${middleware.path}]`);
+        if (middleware.path.includes(":")) {
+            const middlewareParts = middleware.path.split("/");
+            const reqPathParts = req.path.split("/");
+            req.params = {};
             for (let i = 0; i < middlewareParts.length; i++) {
                 if (middlewareParts[i].startsWith(":")) {
-                    continue;
+                    const paramName = middlewareParts[i].slice(1);
+                    req.params[paramName] = reqPathParts[i];
                 }
-                else if (middlewareParts[i] !== urlParts[i]) {
-                    matches = false;
-                    break;
-                }
-            }
-            if (matches) {
-                matchedMiddlewares.push(middleware);
             }
         }
-        else {
-            if (url === cleanedMiddleware) {
-                matchedMiddlewares.push(middleware);
+        req.middleware = middleware;
+        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);
             }
         }
     }
-    return matchedMiddlewares;
-}
-function getMiddlewares(middlewares, matchUrl, basePath = "") {
-    const result = [];
-    for (const middleware of middlewares) {
-        const midPath = (middleware.path || "").replace(/\/+$/, "");
-        const fullPath = (basePath + "/" + midPath).replace(/\/+/g, "/");
-        const matches = matchUrl === fullPath ||
-            (middleware.use && matchUrl.startsWith(fullPath)) ||
-            fullPath.includes(":") ||
-            fullPath.includes("*") ||
-            matchUrl.startsWith(fullPath + "/");
-        if (!matches)
-            continue;
-        if (middleware.router) {
-            const nested = getMiddlewares(middleware.router, matchUrl, fullPath);
-            result.push(...nested);
-        }
-        else {
-            result.push({ ...middleware, path: fullPath });
-        }
+    if (req.method === "GET" && middlewares[middlewares.length - 1]?.sse) {
+        next();
+        return;
     }
-    return result;
+    let body = "";
+    req.on("data", chunk => (body += chunk.toString()));
+    req.on("end", () => {
+        const contentType = req.headers["content-type"] || "";
+        req.body = parseBody(contentType, body);
+        logger.debug(`Request body: ${JSON.stringify(req.body)}`);
+        next();
+    });
 }

package/dist/res.d.ts

@@ -6,14 +6,77 @@ export declare class FFResponse extends http.ServerResponse {
      * bind end for compatibility
     */
     send(data: string): void;
+    /**
+     * Sets a header. This is a shortcut for setHeader.
+     * @param name The name of the header
+     * @param value The value of the header
+     * @returns The response object
+     */
+    header(name: string, value: string): this;
     /**
      * Set content type
      */
-    ct(contentType?: string): void;
+    ct(contentType?: string): this;
+    /**
+     * Set the content type to application/json and write the given data as json
+     * @param data The data to be written as json
+     */
     json(data: any): void;
+    /**
+     * Set a cookie in the response
+     * @param name The name of the cookie
+     * @param value The value of the cookie
+     * @param options The options for the cookie
+     */
     cookie(name: string, value: string, options?: CookieOptions): this;
+    /**
+     * Set the status code for the response
+     * @param code The status code to set
+     * @returns The response object
+     */
     status(code: number): this;
-    redirect(url: string): this;
+    /**
+     * Set status code to 302 and set location header to the provided url.
+     * If end is true, ends the response.
+     * @param url The url to redirect to
+     * @param end Whether to end the response after setting the headers
+     * @returns The response object
+     */
+    redirect(url: string, end?: boolean): this;
+    /**
+     * Sends a file as the response.
+     * Sets the "Content-Type" header based on the provided contentType or the file's extension.
+     * Uses streaming to send the file content.
+     * @param filePath The path to the file to be sent.
+     * @param contentType Optional. The MIME type for the Content-Type header.
+     * If "utf8", the charset will be set to UTF-8.
+     * @returns The response object.
+     */
     sendFile(filePath: string, contentType?: string): this;
-    render(templatePath: string, data: any): this;
+    /**
+     * Renders an HTML template with the provided data and sends it as the response.
+     * Sets the "Content-Type" header to "text/html".
+     * @param templatePath The path to the HTML template file.
+     * @param data An object containing data to be injected into the template.
+     * @returns The response object.
+     */
+    render(templatePath: string, data?: any): this;
+    /**
+     * Initialize SSE headers to start a server-sent event stream.
+     * Sets:
+     *
+     * Content-Type: "text/event-stream"
+     *
+     * Cache-Control: "no-cache"
+     *
+     * Connection: "keep-alive"
+     * @returns The response object
+     */
+    sseInit(): this;
+    /**
+     * Sends a Server-Sent Event to the client.
+     * @param data The data to be sent. If an object, it will be JSON.stringified.
+     * @returns The response object
+     */
+    sseSend(data: string | object): this;
 }

package/dist/res.js

@@ -10,16 +10,37 @@ export class FFResponse extends http.ServerResponse {
     send(data) {
         this.end(data);
     }
+    /**
+     * Sets a header. This is a shortcut for setHeader.
+     * @param name The name of the header
+     * @param value The value of the header
+     * @returns The response object
+     */
+    header(name, value) {
+        this.setHeader(name, value);
+        return this;
+    }
     /**
      * Set content type
      */
     ct(contentType = "text/plain") {
         this.setHeader("Content-Type", contentType);
+        return this;
     }
+    /**
+     * Set the content type to application/json and write the given data as json
+     * @param data The data to be written as json
+     */
     json(data) {
         this.setHeader("Content-Type", "application/json");
         this.end(JSON.stringify(data));
     }
+    /**
+     * Set a cookie in the response
+     * @param name The name of the cookie
+     * @param value The value of the cookie
+     * @param options The options for the cookie
+     */
     cookie(name, value, options = {}) {
         let cookie = `${name}=${encodeURIComponent(value)}`;
         if (options.maxAge)
@@ -35,25 +56,84 @@ export class FFResponse extends http.ServerResponse {
         this.setHeader("Set-Cookie", cookie);
         return this;
     }
+    /**
+     * Set the status code for the response
+     * @param code The status code to set
+     * @returns The response object
+     */
     status(code) {
         this.statusCode = code;
         return this;
     }
-    redirect(url) {
+    /**
+     * Set status code to 302 and set location header to the provided url.
+     * If end is true, ends the response.
+     * @param url The url to redirect to
+     * @param end Whether to end the response after setting the headers
+     * @returns The response object
+     */
+    redirect(url, end = true) {
         this.statusCode = 302;
         this.setHeader("Location", url);
+        if (end)
+            this.end();
         return this;
     }
+    /**
+     * Sends a file as the response.
+     * Sets the "Content-Type" header based on the provided contentType or the file's extension.
+     * Uses streaming to send the file content.
+     * @param filePath The path to the file to be sent.
+     * @param contentType Optional. The MIME type for the Content-Type header.
+     * If "utf8", the charset will be set to UTF-8.
+     * @returns The response object.
+     */
     sendFile(filePath, contentType) {
         if (contentType === "utf8")
             contentType = getContentType(filePath);
         this.ct(contentType || getContentType(filePath));
         createReadStream(filePath).pipe(this);
+        this._ended = true;
         return this;
     }
-    render(templatePath, data) {
+    /**
+     * Renders an HTML template with the provided data and sends it as the response.
+     * Sets the "Content-Type" header to "text/html".
+     * @param templatePath The path to the HTML template file.
+     * @param data An object containing data to be injected into the template.
+     * @returns The response object.
+     */
+    render(templatePath, data = {}) {
         this.setHeader("Content-Type", "text/html");
         this.end(renderHTML(templatePath, data));
         return this;
     }
+    /**
+     * Initialize SSE headers to start a server-sent event stream.
+     * Sets:
+     *
+     * Content-Type: "text/event-stream"
+     *
+     * Cache-Control: "no-cache"
+     *
+     * Connection: "keep-alive"
+     * @returns The response object
+     */
+    sseInit() {
+        this.setHeader("Content-Type", "text/event-stream");
+        this.setHeader("Cache-Control", "no-cache");
+        this.setHeader("Connection", "keep-alive");
+        return this;
+    }
+    /**
+     * Sends a Server-Sent Event to the client.
+     * @param data The data to be sent. If an object, it will be JSON.stringified.
+     * @returns The response object
+     */
+    sseSend(data) {
+        if (typeof data === "object")
+            data = JSON.stringify(data);
+        this.write(`data: ${data}\n\n`);
+        return this;
+    }
 }

package/dist/router.d.ts

@@ -1,12 +1,13 @@
 import { Method, Middleware, RouteHandler } from "./types.js";
 export declare class Router {
     middlewares: Middleware[];
-    addRoute(method: Method, path: string, ...handlers: RouteHandler[]): void;
-    use(path?: string | RouteHandler | Router, middlewareFn?: RouteHandler | Router, method?: Method): void;
-    get(path: string, ...handlers: RouteHandler[]): void;
-    post(path: string, ...handlers: RouteHandler[]): void;
-    put(path: string, ...handlers: RouteHandler[]): void;
-    delete(path: string, ...handlers: RouteHandler[]): void;
-    all(path: string, ...handlers: RouteHandler[]): void;
-    static(apiPath: string, dirPath?: string, utf8?: boolean): void;
+    addRoute(method: Method, path: string, ...handlers: RouteHandler[]): number;
+    use(path?: string | RouteHandler | Router, middlewareFn?: RouteHandler | Router, method?: Method): this;
+    get(path: string, ...handlers: RouteHandler[]): this;
+    post(path: string, ...handlers: RouteHandler[]): this;
+    put(path: string, ...handlers: RouteHandler[]): this;
+    delete(path: string, ...handlers: RouteHandler[]): this;
+    all(path: string, ...handlers: RouteHandler[]): this;
+    static(apiPath: string, dirPath?: string, utf8?: boolean): this;
+    sse(path: string, ...handlers: RouteHandler[]): this;
 }

package/dist/router.js

@@ -4,7 +4,7 @@ export class Router {
     addRoute(method, path, ...handlers) {
         const handler = handlers.pop();
         handlers.forEach(middleware => this.use(path, middleware));
-        this.middlewares.push({ path, middleware: handler, method });
+        return this.middlewares.push({ path, middleware: handler, method });
     }
     use(path = "/", middlewareFn, method = "all") {
         if (typeof path === "function" || path instanceof Router) {
@@ -24,21 +24,27 @@ export class Router {
             middleware.middleware = middlewareFn;
         }
         this.middlewares.push(middleware);
+        return this;
     }
     get(path, ...handlers) {
         this.addRoute("get", path, ...handlers);
+        return this;
     }
     post(path, ...handlers) {
         this.addRoute("post", path, ...handlers);
+        return this;
     }
     put(path, ...handlers) {
         this.addRoute("put", path, ...handlers);
+        return this;
     }
     delete(path, ...handlers) {
         this.addRoute("delete", path, ...handlers);
+        return this;
     }
     all(path, ...handlers) {
         this.addRoute("all", path, ...handlers);
+        return this;
     }
     static(apiPath, dirPath, utf8 = true) {
         if (!dirPath) {
@@ -46,5 +52,11 @@ export class Router {
             apiPath = "/";
         }
         this.use(apiPath, handleStaticFiles(dirPath, utf8));
+        return this;
+    }
+    sse(path, ...handlers) {
+        const index = this.addRoute("get", path, ...handlers);
+        this.middlewares[index - 1].sse = true;
+        return this;
     }
 }

package/dist/types.d.ts

@@ -29,6 +29,7 @@ export interface Middleware {
     middleware: RouteHandler;
     use?: true;
     router?: Middleware[];
+    sse?: true;
 }
 export interface CookieOptions {
     maxAge?: number;

package/package.json

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