clear-router 2.1.11 → 2.2.0

package/dist/express/index.mjs

@@ -1,291 +1,140 @@
-import { n as ClearRequest, t as Route } from "../Route-BbPXcDGX.mjs";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { t as CoreRouter } from "../router-BiCuy5TZ.mjs";
 
 //#region src/express/router.ts
 /**
-* @class clear-router
+* @class clear-router Express Router
 * @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
 * @author Refkinscallv
 * @author 3m1n3nc3
 * @repository https://github.com/toneflix/clear-router
 */
-var Router = class Router {
-	static config = { methodOverride: {
-		enabled: true,
-		bodyKeys: ["_method"],
-		headerKeys: ["x-http-method"]
-	} };
-	static groupContext = new AsyncLocalStorage();
-	/**
-	* All registered routes
-	*/
-	static routes = [];
-	/**
-	* Mapping of routes by path and method for quick lookup.
-	*/
-	static routesByPathMethod = {};
-	/**
-	* Mapping of routes by method for quick lookup.
-	*/
-	static routesByMethod = {};
-	/**
-	* Current route prefix
-	*/
-	static prefix = "";
-	/**
-	* Group-level middlewares
-	*/
-	static groupMiddlewares = [];
-	/**
-	* Global-level middlewares
-	*/
-	static globalMiddlewares = [];
-	/**
-	* Normalize path by removing duplicate slashes and ensuring leading slash
-	* @param path - Path to normalize
-	* @returns Normalized path
-	*/
-	static normalizePath(path) {
-		return "/" + path.split("/").filter(Boolean).join("/");
+var Router = class Router extends CoreRouter {
+	static ensureRequestBodyAccessor(req) {
+		if (typeof req.getBody !== "function") req.getBody = () => req.body ?? {};
 	}
 	/**
-	* Configure router settings to modify behavior.
+	* Adds a new route to the router with the specified HTTP methods, path, handler, and optional middlewares.
 	* 
-	* @param options - Configuration options for the router
-	* @returns 
-	*/
-	static configure(options) {
-		if (!this.config.methodOverride) this.config.methodOverride = {
-			enabled: true,
-			bodyKeys: ["_method"],
-			headerKeys: ["x-http-method"]
-		};
-		const override = options?.methodOverride;
-		if (!override) return;
-		if (typeof override.enabled === "boolean") this.config.methodOverride.enabled = override.enabled;
-		const bodyKeys = override.bodyKeys;
-		if (typeof bodyKeys !== "undefined") this.config.methodOverride.bodyKeys = (Array.isArray(bodyKeys) ? bodyKeys : [bodyKeys]).map((e) => String(e).trim()).filter(Boolean);
-		const headerKeys = override.headerKeys;
-		if (typeof headerKeys !== "undefined") this.config.methodOverride.headerKeys = (Array.isArray(headerKeys) ? headerKeys : [headerKeys]).map((e) => String(e).trim().toLowerCase()).filter(Boolean);
-	}
-	static resolveMethodOverride(method, headers, body) {
-		if (!this.config.methodOverride?.enabled || method.toLowerCase() !== "post") return null;
-		let override;
-		for (const key of this.config.methodOverride?.headerKeys || []) {
-			const value = headers?.[key];
-			if (Array.isArray(value) ? value[0] : value) {
-				override = Array.isArray(value) ? value[0] : value;
-				break;
-			}
-		}
-		if (!override && body && typeof body === "object") for (const key of this.config.methodOverride?.bodyKeys || []) {
-			const value = body[key];
-			if (typeof value !== "undefined" && value !== null && value !== "") {
-				override = value;
-				break;
-			}
-		}
-		const normalized = String(override || "").trim().toLowerCase();
-		if (!normalized) return null;
-		if ([
-			"put",
-			"patch",
-			"delete",
-			"post"
-		].includes(normalized)) return normalized;
-		return null;
-	}
-	/**
-	* Add a route with specified HTTP methods, path, handler, and middlewares
-	* @param methods - HTTP method(s) for the route
-	* @param path - Route path
-	* @param handler - Route handler function or controller reference
-	* @param middlewares - Array of middleware functions
+	* @param methods 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static add(methods, path, handler, middlewares) {
-		const context = this.groupContext.getStore();
-		const activePrefix = context?.prefix ?? this.prefix;
-		const activeGroupMiddlewares = context?.groupMiddlewares ?? this.groupMiddlewares;
-		methods = Array.isArray(methods) ? methods : [methods];
-		middlewares = middlewares ? Array.isArray(middlewares) ? middlewares : [middlewares] : void 0;
-		const fullPath = this.normalizePath(`${activePrefix}/${path}`);
-		const route = new Route(methods.includes("options") ? methods : methods.concat("options"), fullPath, handler, [
-			...this.globalMiddlewares,
-			...activeGroupMiddlewares,
-			...middlewares || []
-		]);
-		if (!methods.includes("options") && !this.routesByPathMethod[`OPTIONS ${fullPath}`]) this.options(path, ({ res }) => {
-			res.set("Allow", "GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD");
-			res.sendStatus(204);
-		});
-		this.routes.push(route);
-		for (const method of methods.map((m) => m.toUpperCase())) {
-			this.routesByPathMethod[`${method.toUpperCase()} ${fullPath}`] = route;
-			if (!this.routesByMethod[method]) this.routesByMethod[method] = [];
-			this.routesByMethod[method].push(route);
-		}
+		super.add(methods, path, handler, middlewares);
 	}
 	/**
-	* Register RESTful API resource routes for a controller with optional action filtering
+	* Adds a new API resource route to the router for the specified base path and controller, with 
+	* optional configuration for included/excluded actions and middlewares.
 	* 
-	* @param basePath - Base path for the resource
-	* @param controller - Controller object containing action methods
-	* @param options - Optional filtering options for actions
+	* @param basePath 
+	* @param controller 
+	* @param options 
 	*/
 	static apiResource(basePath, controller, options) {
-		const actions = {
-			index: {
-				method: "get",
-				path: "/"
-			},
-			show: {
-				method: "get",
-				path: "/:id"
-			},
-			create: {
-				method: "post",
-				path: "/"
-			},
-			update: {
-				method: "put",
-				path: "/:id"
-			},
-			destroy: {
-				method: "delete",
-				path: "/:id"
-			}
-		};
-		const only = options?.only || Object.keys(actions);
-		const except = options?.except || [];
-		const preController = typeof controller === "function" ? new controller() : controller;
-		for (const action of only) {
-			if (except.includes(action)) continue;
-			if (typeof preController[action] === "function") {
-				const { method, path } = actions[action];
-				const actionMiddlewares = typeof options?.middlewares === "object" && !Array.isArray(options.middlewares) ? options.middlewares[action] : options?.middlewares;
-				this.add(method, `${basePath}${path}`, [controller, action], Array.isArray(actionMiddlewares) ? actionMiddlewares : actionMiddlewares ? [actionMiddlewares] : void 0);
-			}
-		}
+		super.apiResource(basePath, controller, options);
 	}
 	/**
-	* Register a GET route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new GET route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static get(path, handler, middlewares) {
-		this.add("get", path, handler, middlewares);
+		super.get(path, handler, middlewares);
 	}
 	/**
-	* Register a POST route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new POST route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static post(path, handler, middlewares) {
-		this.add("post", path, handler, middlewares);
+		super.post(path, handler, middlewares);
 	}
 	/**
-	* Register a PUT route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new PUT route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static put(path, handler, middlewares) {
-		this.add("put", path, handler, middlewares);
+		super.put(path, handler, middlewares);
 	}
 	/**
-	* Register a DELETE route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new DELETE route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static delete(path, handler, middlewares) {
-		this.add("delete", path, handler, middlewares);
+		super.delete(path, handler, middlewares);
 	}
 	/**
-	* Register a PATCH route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new PATCH route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static patch(path, handler, middlewares) {
-		this.add("patch", path, handler, middlewares);
+		super.patch(path, handler, middlewares);
 	}
 	/**
-	* Register an OPTIONS route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new OPTIONS route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static options(path, handler, middlewares) {
-		this.add("options", path, handler, middlewares);
+		super.options(path, handler, middlewares);
 	}
 	/**
-	* Register a HEAD route
-	* @param path - Route path
-	* @param handler - Route handler
-	* @param middlewares - Middleware functions
+	* Adds a new HEAD route to the router with the specified path, handler, and optional middlewares.
+	* 
+	* @param path 
+	* @param handler 
+	* @param middlewares 
 	*/
 	static head(path, handler, middlewares) {
-		this.add("head", path, handler, middlewares);
+		super.head(path, handler, middlewares);
 	}
 	/**
-	* Group routes with a common prefix and middlewares
-	* @param prefix - URL prefix for grouped routes
-	* @param callback - Function containing route definitions
-	* @param middlewares - Middleware functions applied to all routes in group
+	* Defines a group of routes with a common prefix and optional middlewares, allowing for better 
+	* organization and reuse of route configurations.
+	* 
+	* @param prefix 
+	* @param callback 
+	* @param middlewares 
 	*/
 	static async group(prefix, callback, middlewares) {
-		const context = this.groupContext.getStore();
-		const previousPrefix = context?.prefix ?? this.prefix;
-		const previousMiddlewares = context?.groupMiddlewares ?? this.groupMiddlewares;
-		const fullPrefix = [previousPrefix, prefix].filter(Boolean).join("/");
-		const nextContext = {
-			prefix: this.normalizePath(fullPrefix),
-			groupMiddlewares: [...previousMiddlewares, ...middlewares || []]
-		};
-		await this.groupContext.run(nextContext, async () => {
-			await Promise.resolve(callback());
-		});
+		await super.group(prefix, callback, middlewares);
 	}
 	/**
-	* Apply global middlewares for the duration of the callback
-	* @param middlewares - Middleware functions
-	* @param callback - Function containing route definitions
+	* Adds global middlewares to the router, which will be applied to all routes.
+	* 
+	* @param middlewares 
+	* @param callback 
 	*/
 	static middleware(middlewares, callback) {
-		const prevMiddlewares = this.globalMiddlewares;
-		this.globalMiddlewares = [...prevMiddlewares, ...middlewares || []];
-		callback();
-		this.globalMiddlewares = prevMiddlewares;
+		super.middleware(middlewares, callback);
 	}
 	static allRoutes(type) {
-		if (type === "method") return this.routesByMethod;
-		if (type === "path") return this.routesByPathMethod;
-		return this.routes.filter((e) => e.methods.length > 1 || e.methods[0] !== "options");
+		return super.allRoutes(type);
 	}
 	static async apply(router) {
 		for (const route of this.routes) {
 			let handlerFunction = null;
 			let instance = null;
 			try {
-				if (typeof route.handler === "function")
- /** 
-				* Since we do not have a controller instance, we will call the handler function directly and the route instance will be the this argument. This allows for both controller-based and function-based handlers to work seamlessly.
-				*/
-				handlerFunction = route.handler.bind(route);
-				else if (Array.isArray(route.handler) && route.handler.length === 2) {
-					const [Controller, method] = route.handler;
-					if (["function", "object"].includes(typeof Controller) && typeof Controller[method] === "function") {
-						instance = Controller;
-						handlerFunction = Controller[method].bind(Controller);
-					} else if (typeof Controller === "function") {
-						instance = new Controller();
-						if (typeof instance[method] === "function") handlerFunction = instance[method].bind(instance);
-						else throw new Error(`Method "${method}" not found in controller instance "${Controller.name}"`);
-					} else throw new Error(`Invalid controller type for route: ${route.path}`);
-				} else throw new Error(`Invalid handler format for route: ${route.path}`);
+				const resolved = this.resolveHandler(route);
+				handlerFunction = resolved.handlerFunction;
+				instance = resolved.instance;
 			} catch (error) {
 				console.error(`[ROUTES] Error setting up route ${route.path}:`, error.message);
 				throw error;
@@ -307,19 +156,25 @@ var Router = class Router {
 					console.error("[ROUTES]", error.message);
 					throw error;
 				}
-				router[method](route.path, (req, res, next) => {
+				router[method](route.path, (req, _res, next) => {
+					Router.ensureRequestBodyAccessor(req);
 					const override = Router.resolveMethodOverride(req.method, req.headers, req.body);
 					if (method === "post" && override && override !== "post") return next("route");
 					return next();
 				}, ...route.middlewares || [], async (req, res, next) => {
 					try {
+						Router.ensureRequestBodyAccessor(req);
 						const ctx = {
 							req,
 							res,
 							next
 						};
 						const inst = instance ?? route;
-						await Router.bindRequestToInstance(ctx, inst, route);
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: ctx.req.getBody(),
+							query: ctx.req.query,
+							params: ctx.req.params
+						});
 						const result = handlerFunction(ctx, inst.clearRequest);
 						await Promise.resolve(result);
 					} catch (error) {
@@ -330,19 +185,25 @@ var Router = class Router {
 					"put",
 					"patch",
 					"delete"
-				].includes(method)) router.post(route.path, (req, res, next) => {
+				].includes(method)) router.post(route.path, (req, _res, next) => {
+					Router.ensureRequestBodyAccessor(req);
 					if (Router.resolveMethodOverride(req.method, req.headers, req.body) !== method) return next("route");
 					req.method = method.toUpperCase();
 					return next();
 				}, ...route.middlewares || [], async (req, res, next) => {
 					try {
+						Router.ensureRequestBodyAccessor(req);
 						const ctx = {
 							req,
 							res,
 							next
 						};
 						const inst = instance ?? route;
-						await Router.bindRequestToInstance(ctx, inst, route);
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: ctx.req.getBody(),
+							query: ctx.req.query,
+							params: ctx.req.params
+						});
 						const result = handlerFunction(ctx, inst.clearRequest);
 						await Promise.resolve(result);
 					} catch (error) {
@@ -352,20 +213,6 @@ var Router = class Router {
 			}
 		}
 	}
-	static async bindRequestToInstance(ctx, instance, route) {
-		if (!instance) return;
-		instance.ctx = ctx;
-		instance.body = ctx.req.body;
-		instance.query = ctx.req.query;
-		instance.params = ctx.req.params;
-		instance.clearRequest = new ClearRequest({
-			ctx,
-			route,
-			body: instance.body,
-			query: instance.query,
-			params: instance.params
-		});
-	}
 };
 
 //#endregion