@wxn0brp/falcon-frame 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -3,6 +3,7 @@ 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;
@@ -19,4 +20,4 @@ export declare class FalconFrame {
     getApp(): (req: any, res: any) => void;
 }
 export default FalconFrame;
-export { FFResponse, FFRequest, RouteHandler, renderHTML, };
+export { FFResponse, FFRequest, RouteHandler, renderHTML, PluginSystem, };

package/dist/index.js

@@ -5,6 +5,7 @@ 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;
@@ -67,4 +68,4 @@ export class FalconFrame {
     }
 }
 export default FalconFrame;
-export { FFResponse, FFRequest, renderHTML, };
+export { FFResponse, FFRequest, renderHTML, PluginSystem, };

package/dist/plugins/cors.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from "../plugins.js";
+interface Opts {
+    accessControlAllowMethods?: boolean;
+    accessControlAllowHeaders?: boolean;
+}
+export declare function createCORSPlugin(allowedOrigins: string[], opts?: Opts): Plugin;
+export {};

package/dist/plugins/cors.js

@@ -0,0 +1,25 @@
+export function createCORSPlugin(allowedOrigins, opts = {}) {
+    opts = {
+        accessControlAllowMethods: true,
+        accessControlAllowHeaders: true,
+        ...opts,
+    };
+    return {
+        id: "cors",
+        process: (req, res, next) => {
+            const origin = req.headers.origin;
+            if (origin && allowedOrigins.includes(origin)) {
+                res.setHeader("Access-Control-Allow-Origin", origin);
+                if (opts.accessControlAllowMethods)
+                    res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
+                if (opts.accessControlAllowHeaders)
+                    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+            }
+            if (req.method === "OPTIONS") {
+                res.statusCode = 204;
+                return res.end();
+            }
+            next();
+        },
+    };
+}

package/dist/plugins/rateLimit.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "../plugins.js";
+export declare function createRateLimiterPlugin(maxRequests: number, windowMs: number): Plugin;

package/dist/plugins/rateLimit.js

@@ -0,0 +1,23 @@
+export function createRateLimiterPlugin(maxRequests, windowMs) {
+    const rateLimitMap = new Map();
+    return {
+        id: "rateLimiter",
+        process: (req, res, next) => {
+            const ip = req.socket.remoteAddress ?? "unknown";
+            const now = Date.now();
+            const record = rateLimitMap.get(ip);
+            if (!record || now - record.lastRequest > windowMs) {
+                rateLimitMap.set(ip, { count: 1, lastRequest: now });
+                return next();
+            }
+            if (record.count >= maxRequests) {
+                res.statusCode = 429;
+                return res.end("Too Many Requests");
+            }
+            record.count++;
+            record.lastRequest = now;
+            rateLimitMap.set(ip, record);
+            next();
+        },
+    };
+}

package/dist/plugins.d.ts

@@ -0,0 +1,44 @@
+import { RouteHandler } from "./types.js";
+export type PluginId = string;
+export interface Plugin {
+    id: PluginId;
+    process: RouteHandler;
+    priority?: number;
+}
+export interface PluginOptions {
+    before?: PluginId | PluginId[];
+    after?: PluginId | PluginId[];
+    optional?: boolean;
+}
+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?: PluginOptions): 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[];
+}

package/dist/plugins.js

@@ -0,0 +1,93 @@
+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))
+            return;
+        const resolveTarget = (target) => {
+            if (!target)
+                return null;
+            const list = Array.isArray(target) ? target : [target];
+            return list.find(id => this.executionOrder.includes(id)) || null;
+        };
+        const beforeTarget = resolveTarget(options?.before);
+        const afterTarget = resolveTarget(options?.after);
+        if (beforeTarget) {
+            const index = this.executionOrder.indexOf(beforeTarget);
+            this.executionOrder.splice(index, 0, pluginId);
+        }
+        else if (afterTarget) {
+            const index = this.executionOrder.indexOf(afterTarget);
+            this.executionOrder.splice(index + 1, 0, pluginId);
+        }
+        else if (options?.before || options?.after) {
+            if (options.optional) {
+                this.executionOrder.push(pluginId); // fallback: add to the end
+            }
+            else {
+                throw new Error(`Plugin dependency not found for '${pluginId}': ` +
+                    `before=${JSON.stringify(options?.before)}, ` +
+                    `after=${JSON.stringify(options?.after)}`);
+            }
+        }
+        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/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/package.json

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