@wxn0brp/falcon-frame 0.0.13 → 0.0.15

package/README.md

@@ -27,8 +27,17 @@ yarn add @wxn0brp/falcon-frame
 
 ```ts
 import FalconFrame from "@wxn0brp/falcon-frame";
+import { createCORSPlugin } from "@wxn0brp/falcon-frame/plugins/cors";
 const app = new FalconFrame();
 
+const pluginSystem = new PluginSystem();
+
+// Initialize CORS plugin
+pluginSystem.register(createCORSPlugin(["http://localhost:3000", "https://example.com"]));
+
+// Register plugins
+app.use(pluginSystem.getRouteHandler());
+
 const USERS = {
     admin: "hunter2",
 };

package/dist/helpers.d.ts

@@ -1,5 +1,5 @@
 import { Body, Cookies, RouteHandler } from "./types.js";
 export declare function parseCookies(cookieHeader: string): Cookies;
 export declare function parseBody(contentType: string, body: string): Body;
-export declare function getContentType(filePath: string): string;
-export declare function handleStaticFiles(apiPath: string, dirPath: string): RouteHandler;
+export declare function getContentType(filePath: string, utf8?: boolean): string;
+export declare function handleStaticFiles(apiPath: string, dirPath: string, utf8?: boolean): RouteHandler;

package/dist/helpers.js

@@ -24,7 +24,7 @@ export function parseBody(contentType, body) {
     }
     return {};
 }
-export function getContentType(filePath) {
+function _getContentType(filePath) {
     const ext = path.extname(filePath).toLowerCase();
     switch (ext) {
         case ".html":
@@ -44,17 +44,29 @@ export function getContentType(filePath) {
             return "image/gif";
         case ".svg":
             return "image/svg+xml";
+        case ".ico":
+            return "image/x-icon";
+        case ".txt":
+            return "text/plain";
+        case ".pdf":
+            return "application/pdf";
         default:
             return "application/octet-stream";
     }
 }
-export function handleStaticFiles(apiPath, dirPath) {
+export function getContentType(filePath, utf8 = false) {
+    let contentType = _getContentType(filePath);
+    if (utf8)
+        contentType += "; charset=utf-8";
+    return contentType;
+}
+export function handleStaticFiles(apiPath, dirPath, utf8 = true) {
     return (req, res, next) => {
         if (!req.path.startsWith(apiPath))
             return next();
         const filePath = path.join(dirPath, req.path.slice(apiPath.length));
         if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
-            res.setHeader("Content-Type", getContentType(filePath));
+            res.ct(getContentType(filePath, utf8));
             fs.createReadStream(filePath).pipe(res);
             return true;
         }
@@ -62,7 +74,7 @@ export function handleStaticFiles(apiPath, dirPath) {
             if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
                 const indexPath = path.join(filePath, "index.html");
                 if (fs.existsSync(indexPath) && fs.statSync(indexPath).isFile()) {
-                    res.setHeader("Content-Type", getContentType(indexPath));
+                    res.ct(getContentType(indexPath, utf8));
                     fs.createReadStream(indexPath).pipe(res);
                     return true;
                 }

package/dist/index.d.ts

@@ -1,23 +1,18 @@
 import { Logger, LoggerOptions } from "@wxn0brp/lucerna-log";
 import http from "http";
-import { FFResponse } from "./res.js";
-import { AfterHandleRequest, FFRequest, Method, Middleware, RouteHandler } from "./types.js";
-import { renderHTML } from "./render.js";
 import { PluginSystem } from "./plugins.js";
-export declare class FalconFrame {
-    middlewares: Middleware[];
+import { renderHTML } from "./render.js";
+import { FFResponse } from "./res.js";
+import { Router } from "./router.js";
+import { BeforeHandleRequest, FFRequest, RouteHandler } from "./types.js";
+export declare class FalconFrame extends Router {
     logger: Logger;
     constructor(loggerOpts?: LoggerOptions);
-    addRoute(method: Method, path: string, ...handlers: RouteHandler[]): void;
-    use(path?: string | RouteHandler, middleware?: RouteHandler, 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): void;
-    listen(port: number, callback?: () => void, afterHandleRequest?: AfterHandleRequest): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-    getApp(afterHandleRequest?: AfterHandleRequest): (req: any, res: any) => any;
+    listen(port: number, callback?: () => void, beforeHandleRequest?: BeforeHandleRequest): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    getApp(beforeHandleRequest?: BeforeHandleRequest): (req: any, res: any) => Promise<void>;
 }
 export default FalconFrame;
-export { FFResponse, FFRequest, RouteHandler, renderHTML, PluginSystem, };
+export { FFRequest, FFResponse, PluginSystem, renderHTML, RouteHandler, Router };
+export * as Plugins from "./plugins/index.js";
+export * as PluginsEngine from "./plugins.js";
+export * as Helpers from "./helpers.js";

package/dist/index.js

@@ -1,74 +1,38 @@
 import { Logger } from "@wxn0brp/lucerna-log";
 import http from "http";
-import { handleStaticFiles } from "./helpers.js";
+import { PluginSystem } from "./plugins.js";
+import { renderHTML } from "./render.js";
 import { handleRequest } from "./req.js";
 import { FFResponse } from "./res.js";
+import { Router } from "./router.js";
 import { FFRequest } from "./types.js";
-import { renderHTML } from "./render.js";
-import { PluginSystem } from "./plugins.js";
-export class FalconFrame {
-    middlewares = [];
+export class FalconFrame extends Router {
     logger;
     constructor(loggerOpts) {
+        super();
         this.logger = new Logger({
             loggerName: "falcon-frame",
             ...loggerOpts
         });
     }
-    addRoute(method, path, ...handlers) {
-        const handler = handlers.pop();
-        handlers.forEach(middleware => this.use(path, middleware));
-        this.middlewares.push({ path, middleware: handler, method });
-    }
-    use(path = "/", middleware, method = "all") {
-        if (typeof path === "function") {
-            middleware = path;
-            path = "/";
-        }
-        this.middlewares.push({ path, middleware, method, use: true });
-    }
-    get(path, ...handlers) {
-        this.addRoute("get", path, ...handlers);
-    }
-    post(path, ...handlers) {
-        this.addRoute("post", path, ...handlers);
-    }
-    put(path, ...handlers) {
-        this.addRoute("put", path, ...handlers);
-    }
-    delete(path, ...handlers) {
-        this.addRoute("delete", path, ...handlers);
-    }
-    all(path, ...handlers) {
-        this.addRoute("all", path, ...handlers);
-    }
-    static(apiPath, dirPath) {
-        this.middlewares.push({
-            path: (apiPath + "/*").replace("//", "/"),
-            method: "get",
-            middleware: handleStaticFiles(apiPath, dirPath)
-        });
-        this.middlewares.push({
-            path: apiPath,
-            method: "get",
-            middleware: handleStaticFiles(apiPath, dirPath)
-        });
-    }
-    listen(port, callback, afterHandleRequest) {
-        const server = http.createServer(this.getApp(afterHandleRequest));
+    listen(port, callback, beforeHandleRequest) {
+        const server = http.createServer(this.getApp(beforeHandleRequest));
         server.listen(port, callback);
         return server;
     }
-    getApp(afterHandleRequest) {
-        return (req, res) => {
-            if (afterHandleRequest) {
-                const result = afterHandleRequest(req, res);
-                if (result)
-                    return result;
+    getApp(beforeHandleRequest) {
+        return async (req, res) => {
+            if (beforeHandleRequest) {
+                const result = await beforeHandleRequest(req, res);
+                if (result || res._ended)
+                    return;
             }
-            handleRequest(req, res, this);
+            await handleRequest(req, res, this);
         };
     }
 }
 export default FalconFrame;
-export { FFResponse, FFRequest, renderHTML, PluginSystem, };
+export { FFRequest, FFResponse, PluginSystem, renderHTML, Router };
+export * as Plugins from "./plugins/index.js";
+export * as PluginsEngine from "./plugins.js";
+export * as Helpers from "./helpers.js";

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./cors.js";
+export * from "./rateLimit.js";

package/dist/plugins/index.js

@@ -0,0 +1,2 @@
+export * from "./cors.js";
+export * from "./rateLimit.js";

package/dist/req.js

@@ -9,7 +9,7 @@ export function handleRequest(req, res, FF) {
         res._ended = true;
         return originalEnd.call(res, ...any);
     };
-    const { logger, middlewares } = FF;
+    const { logger } = FF;
     try {
         const [path, params] = (req.url || "").split("?");
         const normalizedPath = path.replace(/\/{2,}/g, "/");
@@ -26,6 +26,7 @@ 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", () => {
@@ -116,3 +117,24 @@ function matchMiddleware(url, middlewares) {
     }
     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 ||
+            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/res.d.ts

@@ -2,10 +2,18 @@ import http from "http";
 import { CookieOptions } from "./types.js";
 export declare class FFResponse extends http.ServerResponse {
     _ended: boolean;
+    /**
+     * bind end for compatibility
+    */
+    send(data: string): void;
+    /**
+     * Set content type
+     */
+    ct(contentType?: string): void;
     json(data: any): void;
     cookie(name: string, value: string, options?: CookieOptions): this;
     status(code: number): this;
     redirect(url: string): this;
-    sendFile(filePath: string): this;
+    sendFile(filePath: string, contentType?: string): this;
     render(templatePath: string, data: any): this;
 }

package/dist/res.js

@@ -4,6 +4,18 @@ import { createReadStream } from "fs";
 import { renderHTML } from "./render.js";
 export class FFResponse extends http.ServerResponse {
     _ended = false;
+    /**
+     * bind end for compatibility
+    */
+    send(data) {
+        this.end(data);
+    }
+    /**
+     * Set content type
+     */
+    ct(contentType = "text/plain") {
+        this.setHeader("Content-Type", contentType);
+    }
     json(data) {
         this.setHeader("Content-Type", "application/json");
         this.end(JSON.stringify(data));
@@ -32,8 +44,10 @@ export class FFResponse extends http.ServerResponse {
         this.setHeader("Location", url);
         return this;
     }
-    sendFile(filePath) {
-        this.setHeader("Content-Type", getContentType(filePath));
+    sendFile(filePath, contentType) {
+        if (contentType === "utf8")
+            contentType = getContentType(filePath);
+        this.ct(contentType || getContentType(filePath));
         createReadStream(filePath).pipe(this);
         return this;
     }

package/dist/router.d.ts

@@ -0,0 +1,12 @@
+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;
+}

package/dist/router.js

@@ -0,0 +1,59 @@
+import { handleStaticFiles } from "./helpers.js";
+export class Router {
+    middlewares = [];
+    addRoute(method, path, ...handlers) {
+        const handler = handlers.pop();
+        handlers.forEach(middleware => this.use(path, middleware));
+        this.middlewares.push({ path, middleware: handler, method });
+    }
+    use(path = "/", middlewareFn, method = "all") {
+        if (typeof path === "function" || path instanceof Router) {
+            middlewareFn = path;
+            path = "/";
+        }
+        const middleware = {
+            path,
+            method,
+            middleware: null,
+            use: true
+        };
+        if (middlewareFn instanceof Router) {
+            middleware.router = middlewareFn.middlewares;
+        }
+        else {
+            middleware.middleware = middlewareFn;
+        }
+        this.middlewares.push(middleware);
+    }
+    get(path, ...handlers) {
+        this.addRoute("get", path, ...handlers);
+    }
+    post(path, ...handlers) {
+        this.addRoute("post", path, ...handlers);
+    }
+    put(path, ...handlers) {
+        this.addRoute("put", path, ...handlers);
+    }
+    delete(path, ...handlers) {
+        this.addRoute("delete", path, ...handlers);
+    }
+    all(path, ...handlers) {
+        this.addRoute("all", path, ...handlers);
+    }
+    static(apiPath, dirPath, utf8 = true) {
+        if (!dirPath) {
+            dirPath = apiPath;
+            apiPath = "/";
+        }
+        this.middlewares.push({
+            path: (apiPath + "/*").replace("//", "/"),
+            method: "get",
+            middleware: handleStaticFiles(apiPath, dirPath, utf8)
+        });
+        this.middlewares.push({
+            path: apiPath,
+            method: "get",
+            middleware: handleStaticFiles(apiPath, dirPath, utf8)
+        });
+    }
+}

package/dist/types.d.ts

@@ -27,6 +27,7 @@ export interface Middleware {
     method: Method;
     middleware: RouteHandler;
     use?: true;
+    router?: Middleware[];
 }
 export interface CookieOptions {
     maxAge?: number;
@@ -44,4 +45,4 @@ export interface ValidationResult {
         [key: string]: string[];
     };
 }
-export type AfterHandleRequest = (req: http.IncomingMessage, res: http.ServerResponse) => any;
+export type BeforeHandleRequest = (req: http.IncomingMessage, res: http.ServerResponse) => any;

package/package.json

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

package/dist/test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test.js

@@ -1,76 +0,0 @@
-import FalconFrame, { PluginSystem } from "./index.js";
-const app = new FalconFrame({
-    logLevel: "INFO",
-});
-const pluginSystem = new PluginSystem();
-pluginSystem.register({
-    id: "logger",
-    process: (req, res, next) => {
-        console.log(`Request to ${req.url} with body ${JSON.stringify(req.body)}`);
-        next();
-    }
-});
-pluginSystem.register({
-    id: "logger2",
-    process: (req, res, next) => {
-        req.body.test = "test";
-        next();
-    }
-}, { before: "logger" });
-app.use((req, res, next) => {
-    console.log(`[${req.method}] ${req.path}`);
-    next();
-});
-app.use(pluginSystem.getRouteHandler());
-app.static("/", "public");
-app.get("/hello", (req, res) => {
-    const name = req.query.name || "World";
-    res.json({
-        message: `Hello, ${name}?`,
-        query: req.query,
-    });
-});
-app.get("/hello/*", (req, res) => {
-    res.json({
-        message: `Hello, ${req.params.name}!`,
-        query: req.query,
-    });
-});
-app.get("/greet/:name", (req, res, next) => {
-    console.log(req.params);
-    next();
-}, (req, res) => {
-    res.json({
-        message: `Hello, ${req.params.name}!`,
-    });
-});
-app.post("/submit", (req, res, next) => {
-    const { validErrors, valid } = req.valid({
-        login: "required|string",
-        password: "required|string|min:8",
-    });
-    if (!valid) {
-        res.status(400).json({
-            status: "error",
-            errors: validErrors,
-        });
-    }
-    else
-        next();
-}, async (req, res) => {
-    console.log("run");
-    res.redirect("/hello?name=" + req.body.login);
-    return {
-        status: "success",
-        data: `Hello ${req.body.login}`,
-    };
-});
-app.use((req, res) => {
-    res.status(404);
-    res.json({
-        message: "Not found",
-    });
-});
-app.listen(3000, () => {
-    console.log("Server running on http://localhost:3000");
-});