@wxn0brp/falcon-frame-plugin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wxn0brP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { RouteHandler } from "@wxn0brp/falcon-frame";
+import { Plugin, PSOpts } from "./types.js";
+export declare class PluginSystem {
+    plugins: Plugin[];
+    _sorted: boolean;
+    /**
+     * Registers a plugin with the system.
+     * If the opts.after or opts.before properties are provided, they will be used to set the after and before properties of the plugin respectively.
+     * If the plugins have already been sorted, the plugins will be re-sorted after registration.
+     * @param plugin The plugin to register
+     * @param opts Options for registering the plugin
+     */
+    register(plugin: Plugin, opts?: PSOpts): void;
+    /**
+     * Sorts the plugins using the sortPlugins function and marks them as sorted
+     */
+    _sort(): void;
+    /**
+     * Returns a RouteHandler function that executes all registered plugins in the correct order
+     * When called, it will first sort the plugins if they haven't been sorted yet
+     * Then it will return a function that takes a request, response, and next function as arguments
+     * This returned function will recursively execute all plugins in the correct order
+     * @returns A RouteHandler function
+     */
+    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;
+}

package/dist/index.js

@@ -0,0 +1,55 @@
+import { sortPlugins } from "./sort/index.js";
+export class PluginSystem {
+    plugins = [];
+    _sorted = false;
+    /**
+     * Registers a plugin with the system.
+     * If the opts.after or opts.before properties are provided, they will be used to set the after and before properties of the plugin respectively.
+     * If the plugins have already been sorted, the plugins will be re-sorted after registration.
+     * @param plugin The plugin to register
+     * @param opts Options for registering the plugin
+     */
+    register(plugin, opts = {}) {
+        if (opts.after)
+            plugin.after = opts.after;
+        if (opts.before)
+            plugin.before = opts.before;
+        this.plugins.push(plugin);
+        if (this._sorted)
+            this._sort();
+    }
+    /**
+     * Sorts the plugins using the sortPlugins function and marks them as sorted
+     */
+    _sort() {
+        this.plugins = sortPlugins(this.plugins);
+        this._sorted = true;
+    }
+    /**
+     * Returns a RouteHandler function that executes all registered plugins in the correct order
+     * When called, it will first sort the plugins if they haven't been sorted yet
+     * Then it will return a function that takes a request, response, and next function as arguments
+     * This returned function will recursively execute all plugins in the correct order
+     * @returns A RouteHandler function
+     */
+    getRouteHandler() {
+        this._sort();
+        return (req, res, next) => {
+            return 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.plugins.length)
+            return next();
+        this.plugins[index].process(req, res, () => {
+            this.executePlugins(req, res, next, index + 1);
+        });
+    }
+}

package/dist/plugins/rateLimit.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "../types.js";
+export interface RateLimitRecord {
+    count: number;
+    lastRequest: number;
+}
+export declare function createRateLimiterPlugin(maxRequests: number, windowMs: number): Plugin;

package/dist/plugins/rateLimit.js

@@ -0,0 +1,24 @@
+;
+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/security.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "../types.js";
+export declare function createSecurityPlugin(): Plugin;

package/dist/plugins/security.js

@@ -0,0 +1,14 @@
+export function createSecurityPlugin() {
+    return {
+        id: "security",
+        process: (req, res, next) => {
+            res.setHeader("X-Content-Type-Options", "nosniff");
+            res.setHeader("X-Frame-Options", "SAMEORIGIN");
+            res.setHeader("Referrer-Policy", "no-referrer");
+            res.setHeader("X-XSS-Protection", "1; mode=block");
+            res.setHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
+            next();
+        },
+        after: "cors",
+    };
+}

package/dist/sort/index.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from "../types.js";
+export declare function sortPlugins(plugins: Plugin[]): Plugin[];

package/dist/sort/index.js

@@ -0,0 +1,32 @@
+import { sort } from "./lib.js";
+export function sortPlugins(plugins) {
+    const edges = [];
+    const ids = new Set();
+    for (const plugin of plugins) {
+        if (ids.has(plugin.id)) {
+            throw new Error(`Duplicate plugin id: "${plugin.id}"`);
+        }
+        ids.add(plugin.id);
+    }
+    for (const plugin of plugins) {
+        const { id, before, after } = plugin;
+        const addEdge = (from, to) => {
+            if (from !== to && ids.has(from) && ids.has(to)) {
+                edges.push([from, to]);
+            }
+        };
+        if (before) {
+            const beforeList = Array.isArray(before) ? before : [before];
+            for (const b of beforeList)
+                addEdge(id, b);
+        }
+        if (after) {
+            const afterList = Array.isArray(after) ? after : [after];
+            for (const a of afterList)
+                addEdge(a, id);
+        }
+    }
+    const sortedIds = sort([...ids], edges);
+    const byId = new Map(plugins.map(p => [p.id, p]));
+    return sortedIds.map(id => byId.get(id));
+}

package/dist/sort/lib.d.ts

@@ -0,0 +1,3 @@
+type Edge<T> = [T, T];
+export declare function sort<T>(nodes: T[], edges: Edge<T>[]): T[];
+export {};

package/dist/sort/lib.js

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2012 by Marcel Klehr <mklehr@gmx.net>
+ * Modified and rewritten by wxn0brP (2025)
+ * Licensed under the MIT License
+ */
+function makeOutgoingEdges(edges) {
+    const outgoingEdges = new Map();
+    for (const [from, to] of edges) {
+        if (!outgoingEdges.has(from)) {
+            outgoingEdges.set(from, new Set());
+        }
+        if (!outgoingEdges.has(to)) {
+            outgoingEdges.set(to, new Set());
+        }
+        outgoingEdges.get(from).add(to);
+    }
+    return outgoingEdges;
+}
+function makeNodesHash(nodes) {
+    const hash = new Map();
+    nodes.forEach((node, index) => {
+        hash.set(node, index);
+    });
+    return hash;
+}
+export function sort(nodes, edges) {
+    const cursor = { value: nodes.length };
+    const sorted = new Array(cursor.value);
+    const visited = new Set();
+    const outgoingEdges = makeOutgoingEdges(edges);
+    const nodesHash = makeNodesHash(nodes);
+    for (const [from, to] of edges) {
+        if (!nodesHash.has(from) || !nodesHash.has(to)) {
+            throw new Error("Unknown node. There is an unknown node in the supplied edges.");
+        }
+    }
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        if (!visited.has(i)) {
+            visit(nodes[i], i, new Set());
+        }
+    }
+    return sorted;
+    function visit(node, index, predecessors) {
+        if (predecessors.has(node)) {
+            let nodeRep = "";
+            try {
+                nodeRep = `, node was: ${JSON.stringify(node)}`;
+            }
+            catch (e) {
+                nodeRep = "";
+            }
+            throw new Error(`Cyclic dependency ${nodeRep}`);
+        }
+        if (!nodesHash.has(node)) {
+            throw new Error(`Found unknown node. Make sure to provide all involved nodes. Unknown node: ${JSON.stringify(node)}`);
+        }
+        if (visited.has(index))
+            return;
+        visited.add(index);
+        const outgoing = outgoingEdges.get(node) || new Set();
+        const outgoingArray = Array.from(outgoing);
+        if (outgoingArray.length > 0) {
+            predecessors.add(node);
+            for (const child of outgoingArray) {
+                const childIndex = nodesHash.get(child);
+                visit(child, childIndex, predecessors);
+            }
+            predecessors.delete(node);
+        }
+        sorted[--cursor.value] = node;
+    }
+}

package/dist/test.d.ts

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

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+import { RouteHandler } from "@wxn0brp/falcon-frame";
+export interface Plugin {
+    id: string;
+    process: RouteHandler;
+    before?: string | string[];
+    after?: string | string[];
+}
+export interface PSOpts {
+    before?: string | string[];
+    after?: string | string[];
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,42 @@
+{
+	"name": "@wxn0brp/falcon-frame-plugin",
+	"version": "0.0.1",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"description": "",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/wxn0brP/FalconFrame-plugin.git"
+	},
+	"homepage": "https://github.com/wxn0brP/FalconFrame-plugin",
+	"author": "wxn0brP",
+	"license": "MIT",
+	"type": "module",
+	"scripts": {
+		"build": "tsc && tsc-alias"
+	},
+	"devDependencies": {
+		"@types/bun": "*",
+		"@wxn0brp/falcon-frame": "^0.5.0",
+		"tsc-alias": "*",
+		"typescript": "*"
+	},
+	"peerDependencies": {
+		"@wxn0brp/falcon-frame": ">=0.5.0"
+	},
+	"files": [
+		"dist"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		},
+		"./*": {
+			"types": "./dist/*.d.ts",
+			"import": "./dist/*.js",
+			"default": "./dist/*.js"
+		}
+	}
+}