clear-router 2.1.12 → 2.2.0

package/dist/h3/index.d.mts

@@ -1,64 +1,32 @@
-import { c as Route, d as HttpContext, f as Middleware, i as RouterConfig, l as H3App, n as ControllerAction, r as HttpMethod, t as ApiResourceMiddleware, u as Handler } from "../basic-cLeny2Zk.mjs";
+import { c as Route, d as HttpContext, f as Middleware, i as HttpMethod, l as H3App, n as ApiResourceMiddleware, r as ControllerAction, t as CoreRouter, u as Handler } from "../router-C1jVRytA.mjs";
 import { H3 } from "h3";
 
 //#region src/h3/router.d.ts
 /**
- * @class clear-router
+ * @class clear-router H3 Router
  * @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
  * @author 3m1n3nc3
  * @repository https://github.com/toneflix/clear-router
  */
-declare class Router {
-  static config: RouterConfig;
+declare class Router extends CoreRouter {
   private static readonly bodyCache;
-  private static readonly groupContext;
-  /**
-   * All registered routes
-   */
-  static routes: Array<Route<HttpContext, Middleware>>;
-  /**
-   * Mapping of routes by path and method for quick lookup.
-   */
-  static routesByPathMethod: Record<string, Route<HttpContext, Middleware>>;
-  /**
-   * Mapping of routes by method for quick lookup.
-   */
-  static routesByMethod: { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware>> };
-  /**
-   * Current route prefix
-   */
-  static prefix: string;
-  /**
-   * Group-level middlewares
-   */
-  static groupMiddlewares: Middleware[];
-  /**
-   * Global-level middlewares
-   */
-  static globalMiddlewares: Middleware[];
-  /**
-   * Normalize path by removing duplicate slashes and ensuring leading slash
-   * @param path - Path to normalize
-   * @returns Normalized path
-   */
-  static normalizePath(path: string): string;
-  static configure(options?: RouterConfig): void;
   private static readBodyCached;
-  private static resolveMethodOverride;
   /**
-    * 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
-    */
+   * Adds a new route to the router with the specified HTTP methods, path, handler, and optional middlewares.
+   *
+   * @param methods
+   * @param path
+   * @param handler
+   * @param middlewares
+   */
   static add(methods: HttpMethod | HttpMethod[], path: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * Register RESTful API resource routes for a controller with optional action filtering
+   * Adds a new API resource route to the router for a given base path and controller, with options
+   * to specify 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: string, controller: any, options?: {
     only?: ControllerAction[];
@@ -66,83 +34,94 @@ declare class Router {
     middlewares?: ApiResourceMiddleware<Middleware>;
   }): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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: string, handler: Handler, middlewares?: Middleware[] | Middleware): void;
   /**
-   * 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 group(prefix: string, callback: () => void | Promise<void>, middlewares?: Middleware[]): Promise<void>;
   /**
-   * 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: Middleware[], callback: () => void): void;
   /**
-   * Get all registered routes with their information
-   * @returns Array of route information objects
-  */
-  static allRoutes(): Array<Route<HttpContext, Middleware>>;
-  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware>>;
-  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware>> };
+   * Retrieves all registered routes in the router, optionally organized by path or method
+   * for easier access and management.
+   *
+   * @param type
+   */
+  static allRoutes(): Array<Route<HttpContext, Middleware, Handler>>;
+  static allRoutes(type: 'path'): Record<string, Route<HttpContext, Middleware, Handler>>;
+  static allRoutes(type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<HttpContext, Middleware, Handler>> };
   /**
-   * Apply all registered routes to the provided H3 Router instance
-   * Handles controller-method binding and middleware application
-   * All errors are thrown to H3 error handling middleware
+   * Applies the registered routes to the given H3 application instance, setting up the
+   * necessary handlers and middlewares for each route.
    *
-   * @param app - H3 app instance
+   * @param app
+   * @returns
    */
   static apply(app: H3): H3App;
-  private static bindRequestToInstance;
 }
 //#endregion
 export { Router };

package/dist/h3/index.mjs

@@ -1,68 +1,15 @@
-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";
 import { getQuery, getRouterParams, readBody } from "h3";
 
 //#region src/h3/router.ts
 /**
-* @class clear-router
+* @class clear-router H3 Router
 * @description Laravel-style routing system for Express.js and H3 with support for CommonJS, ESM, and TypeScript
 * @author 3m1n3nc3
 * @repository https://github.com/toneflix/clear-router
 */
-var Router = class Router {
-	static config = { methodOverride: {
-		enabled: true,
-		bodyKeys: ["_method"],
-		headerKeys: ["x-http-method"]
-	} };
+var Router = class Router extends CoreRouter {
 	static bodyCache = /* @__PURE__ */ new WeakMap();
-	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("/");
-	}
-	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 async readBodyCached(ctx) {
 		if (this.bodyCache.has(ctx)) {
 			const cached = this.bodyCache.get(ctx);
@@ -78,231 +25,136 @@ var Router = class Router {
 		this.bodyCache.set(ctx, body);
 		return body;
 	}
-	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.get(key);
-			if (value) {
-				override = 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
+	* Adds a new route to the router with the specified HTTP methods, path, handler, and optional middlewares.
+	* 
+	* @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.headers.set("Allow", "GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD");
-			res.status = 204;
-		});
-		this.routes.push(route);
-		for (const method of methods.map((m) => m.toUpperCase())) {
-			this.routesByPathMethod[`${method} ${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 a given base path and controller, with options 
+	* to specify 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);
 	}
 	/**
-	* Apply all registered routes to the provided H3 Router instance
-	* Handles controller-method binding and middleware application
-	* All errors are thrown to H3 error handling middleware
+	* Applies the registered routes to the given H3 application instance, setting up the 
+	* necessary handlers and middlewares for each route.
 	* 
-	* @param app - H3 app instance
+	* @param app 
+	* @returns 
 	*/
 	static apply(app) {
 		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;
@@ -331,7 +183,11 @@ var Router = class Router {
 						const override = Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody);
 						if (method === "post" && override && override !== "post") return;
 						const inst = instance ?? route;
-						await Router.bindRequestToInstance(ctx, inst, route, reqBody);
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: reqBody,
+							query: getQuery(ctx),
+							params: getRouterParams(ctx, { decode: true })
+						});
 						const result = handlerFunction(ctx, inst.clearRequest);
 						return await Promise.resolve(result);
 					} catch (error) {
@@ -348,7 +204,11 @@ var Router = class Router {
 						const reqBody = await Router.readBodyCached(ctx);
 						if (Router.resolveMethodOverride(ctx.req.method, ctx.req.headers, reqBody) !== method) return;
 						const inst = instance ?? route;
-						await Router.bindRequestToInstance(ctx, inst, route, reqBody);
+						Router.bindRequestToInstance(ctx, inst, route, {
+							body: reqBody,
+							query: getQuery(ctx),
+							params: getRouterParams(ctx, { decode: true })
+						});
 						const result = handlerFunction(ctx, inst.clearRequest);
 						return await Promise.resolve(result);
 					} catch (error) {
@@ -359,20 +219,6 @@ var Router = class Router {
 		}
 		return app;
 	}
-	static async bindRequestToInstance(ctx, instance, route, body) {
-		if (!instance) return;
-		instance.ctx = ctx;
-		instance.body = body ?? await Router.readBodyCached(ctx);
-		instance.query = getQuery(ctx);
-		instance.params = getRouterParams(ctx, { decode: true });
-		instance.clearRequest = new ClearRequest({
-			ctx,
-			route,
-			body: instance.body,
-			query: instance.query,
-			params: instance.params
-		});
-	}
 };
 
 //#endregion