@wxn0brp/falcon-frame 0.0.6 → 0.0.7

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

@@ -1,10 +1,15 @@
 import { RouteHandler } from "./types.js";
-type PluginId = string;
-interface Plugin {
+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;
@@ -13,10 +18,7 @@ export declare class PluginSystem {
      * @param plugin - Plugin to register
      * @param options - Options for positioning plugins
      */
-    register(plugin: Plugin, options?: {
-        before?: PluginId;
-        after?: PluginId;
-    }): void;
+    register(plugin: Plugin, options?: PluginOptions): void;
     /**
      * Updates the execution order of plugins
      * @param pluginId - ID of the plugin to position
@@ -40,4 +42,3 @@ export declare class PluginSystem {
      */
     getPluginsInOrder(): Plugin[];
 }
-export {};

package/dist/plugins.js

@@ -21,25 +21,37 @@ export class PluginSystem {
      * @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);
+        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 {
-                this.executionOrder.push(pluginId);
+                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

package/package.json

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