@wxn0brp/falcon-frame 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -2,6 +2,8 @@ import { Logger, LoggerOptions } from "@wxn0brp/lucerna-log";
 import http from "http";
 import { FFResponse } from "./res.js";
 import { FFRequest, Method, Middleware, RouteHandler } from "./types.js";
+import { renderHTML } from "./render.js";
+import { PluginSystem } from "./plugins.js";
 export declare class FalconFrame {
     middlewares: Middleware[];
     logger: Logger;
@@ -18,4 +20,4 @@ export declare class FalconFrame {
     getApp(): (req: any, res: any) => void;
 }
 export default FalconFrame;
-export { FFResponse, FFRequest, RouteHandler, };
+export { FFResponse, FFRequest, RouteHandler, renderHTML, PluginSystem, };

package/dist/index.js

@@ -4,6 +4,8 @@ import { handleStaticFiles } from "./helpers.js";
 import { handleRequest } from "./req.js";
 import { FFResponse } from "./res.js";
 import { FFRequest } from "./types.js";
+import { renderHTML } from "./render.js";
+import { PluginSystem } from "./plugins.js";
 export class FalconFrame {
     middlewares = [];
     logger;
@@ -66,4 +68,4 @@ export class FalconFrame {
     }
 }
 export default FalconFrame;
-export { FFResponse, FFRequest, };
+export { FFResponse, FFRequest, renderHTML, PluginSystem, };

package/dist/plugins.d.ts

@@ -0,0 +1,43 @@
+import { RouteHandler } from "./types.js";
+type PluginId = string;
+interface Plugin {
+    id: PluginId;
+    process: RouteHandler;
+    priority?: number;
+}
+export declare class PluginSystem {
+    private plugins;
+    private executionOrder;
+    /**
+     * Registers a new plugin in the system
+     * @param plugin - Plugin to register
+     * @param options - Options for positioning plugins
+     */
+    register(plugin: Plugin, options?: {
+        before?: PluginId;
+        after?: PluginId;
+    }): void;
+    /**
+     * Updates the execution order of plugins
+     * @param pluginId - ID of the plugin to position
+     * @param options - Options for positioning
+     */
+    private updateExecutionOrder;
+    /**
+     * Returns a RouteHandler that executes all registered plugins in the correct order
+     */
+    getRouteHandler(): RouteHandler;
+    /**
+     * Recursively executes plugins in the correct order
+     * @param req - Request object
+     * @param res - Response object
+     * @param next - Next function
+     * @param index - Current index in the execution order
+     */
+    private executePlugins;
+    /**
+     * Returns the list of plugins in the execution order
+     */
+    getPluginsInOrder(): Plugin[];
+}
+export {};

package/dist/plugins.js

@@ -0,0 +1,81 @@
+export class PluginSystem {
+    plugins = [];
+    executionOrder = [];
+    /**
+     * Registers a new plugin in the system
+     * @param plugin - Plugin to register
+     * @param options - Options for positioning plugins
+     */
+    register(plugin, options) {
+        if (this.plugins.some(p => p.id === plugin.id)) {
+            throw new Error(`Plugin with id '${plugin.id}' already registered`);
+        }
+        // Add plugin to the list
+        this.plugins.push(plugin);
+        // Update the execution order
+        this.updateExecutionOrder(plugin.id, options);
+    }
+    /**
+     * Updates the execution order of plugins
+     * @param pluginId - ID of the plugin to position
+     * @param options - Options for positioning
+     */
+    updateExecutionOrder(pluginId, options) {
+        if (!this.executionOrder.includes(pluginId)) {
+            if (options?.before) {
+                const index = this.executionOrder.indexOf(options.before);
+                if (index === -1) {
+                    throw new Error(`Plugin '${options.before}' not found`);
+                }
+                this.executionOrder.splice(index, 0, pluginId);
+            }
+            else if (options?.after) {
+                const index = this.executionOrder.indexOf(options.after);
+                if (index === -1) {
+                    throw new Error(`Plugin '${options.after}' not found`);
+                }
+                this.executionOrder.splice(index + 1, 0, pluginId);
+            }
+            else {
+                this.executionOrder.push(pluginId);
+            }
+        }
+    }
+    /**
+     * Returns a RouteHandler that executes all registered plugins in the correct order
+     */
+    getRouteHandler() {
+        return (req, res, next) => {
+            this.executePlugins(req, res, next, 0);
+        };
+    }
+    /**
+     * Recursively executes plugins in the correct order
+     * @param req - Request object
+     * @param res - Response object
+     * @param next - Next function
+     * @param index - Current index in the execution order
+     */
+    executePlugins(req, res, next, index) {
+        if (index >= this.executionOrder.length) {
+            next();
+            return;
+        }
+        const pluginId = this.executionOrder[index];
+        const plugin = this.plugins.find(p => p.id === pluginId);
+        if (!plugin) {
+            throw new Error(`Plugin '${pluginId}' not found`);
+        }
+        plugin.process(req, res, () => {
+            this.executePlugins(req, res, next, index + 1);
+        });
+    }
+    /**
+     * Returns the list of plugins in the execution order
+     */
+    getPluginsInOrder() {
+        return this.executionOrder
+            .map(id => this.plugins.find(p => p.id === id))
+            .filter((p) => p !== undefined);
+    }
+}

package/dist/render.d.ts

@@ -0,0 +1,5 @@
+interface RenderData {
+    [key: string]: string;
+}
+export declare function renderHTML(templatePath: string, data: RenderData): string;
+export {};

package/dist/render.js

@@ -0,0 +1,16 @@
+import fs from "fs";
+import path from "path";
+export function renderHTML(templatePath, data) {
+    let template = fs.readFileSync(templatePath, "utf8");
+    // Inserting data, e.g. {{name}}
+    template = template.replace(/{{(.*?)}}/g, (_, key) => data[key.trim()] || "");
+    // Loading partials, e.g. <!-- include header -->
+    template = template.replace(/<!--\s*include\s*(.*?)\s*-->/g, (_, partialName) => {
+        const partialPath = path.join(path.dirname(templatePath), partialName + ".html");
+        if (fs.existsSync(partialPath))
+            return renderHTML(partialPath, data);
+        else
+            return `<!-- Partial "${partialName}" (${partialPath.replace(process.cwd() + "/", "")}) not found -->`;
+    });
+    return template;
+}

package/dist/res.d.ts

@@ -7,4 +7,5 @@ export declare class FFResponse extends http.ServerResponse {
     status(code: number): this;
     redirect(url: string): this;
     sendFile(filePath: string): this;
+    render(templatePath: string, data: any): this;
 }

package/dist/res.js

@@ -1,6 +1,7 @@
 import http from "http";
 import { getContentType } from "./helpers.js";
 import { createReadStream } from "fs";
+import { renderHTML } from "./render.js";
 export class FFResponse extends http.ServerResponse {
     _ended = false;
     json(data) {
@@ -36,4 +37,9 @@ export class FFResponse extends http.ServerResponse {
         createReadStream(filePath).pipe(this);
         return this;
     }
+    render(templatePath, data) {
+        this.setHeader("Content-Type", "text/html");
+        this.end(renderHTML(templatePath, data));
+        return this;
+    }
 }

package/dist/test.js

@@ -1,11 +1,27 @@
-import FalconFrame from "./index.js";
+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";

package/dist/types.d.ts

@@ -9,7 +9,7 @@ export interface Cookies {
     [key: string]: string;
 }
 export interface Query {
-    [key: string]: string | string[];
+    [key: string]: string;
 }
 export interface Body {
     [key: string]: any;

package/package.json

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