clear-router 2.0.8 → 2.1.1

package/README.md

@@ -1,6 +1,6 @@
-# Toneflix Clear Router
+# Clear Router
 
-Laravel-style routing system for Express.js in JavaScript. Clean route definitions, middleware support, and controller bindings with full TypeScript support.
+Laravel-style routing system for H3 and Express.js, with clean route definitions, middleware support, controller bindings and full TypeScript support.
 
 ## Installation
 
@@ -19,7 +19,7 @@ pnpm add clear-router h3
 
 # OR
 
-pnpm add clear-router hexpress3
+pnpm add clear-router express
 ```
 
 OR
@@ -39,10 +39,13 @@ yarn add clear-router express
 - Middleware stack: per-route and group-level
 - Controller-method pair as route handler
 - Supports HttpContext style handlers: { req, res, next }
+- Function handlers always receive context as first argument
+- Controller handlers receive hydrated `this.body`, `this.query`, `this.params`, and `this.clearRequest`
+- `clearRequest` is passed as second handler argument for controller handlers
 - Auto-binds controller methods
 - Full CommonJS, ESM, and TypeScript support
-- Error handling delegated to Express
-- Route inspection with allRoutes method
+- Error handling delegated to Express | H3
+- Route inspection with the `allRoutes` method
 - Fully Express-compatible
 - Fully H3-compatible
 
@@ -60,20 +63,9 @@ See the [H3 documentation](./docs/H3.md) for details.
 
 See [API.md](./docs/API.md) for complete API documentation.
 
-## Error Handling
-
-All errors during route execution are automatically passed to Express error handling middleware using `next(error)`. You can define your error handler:
-
-```javascript
-app.use((err, req, res, next) => {
-  console.error(err);
-  res.status(500).json({ error: err.message });
-});
-```
-
 ## Middleware Execution Order
 
-```
+```txt
 [ Global Middleware ] → [ Group Middleware ] → [ Route Middleware ]
 ```
 
@@ -81,6 +73,8 @@ app.use((err, req, res, next) => {
 
 - If function: executed directly
 - If [Controller, 'method']: auto-instantiated (if needed), method is called
+- First handler arg is always context (`{ req, res, next }` for Express, H3 event for H3)
+- Second handler arg is `clearRequest` for controller handlers
 
 ## Testing
 
@@ -91,7 +85,7 @@ npm run test:esm      # Test ESM
 npm run test:ts       # Test TypeScript
 ```
 
-See [TESTING.md](./docs/TESTING.md) for detailed testing guide.
+See [TESTING.md](./docs/TESTING.md) for a detailed testing guide.
 
 ## Examples
 
@@ -101,7 +95,7 @@ npm run example:esm   # ESM example
 npm run example:ts    # TypeScript example
 ```
 
-Check `example/` directory for full working demos.
+Check the `example/` directory for full working demos.
 
 ## Changelog
 

package/dist/Route-97p-tEbS.cjs

@@ -0,0 +1,54 @@
+
+//#region src/ClearRequest.ts
+var ClearRequest = class {
+	/**
+	* @param body - Parsed request body
+	*/
+	body;
+	/**
+	* @param query - Parsed query parameters
+	*/
+	query;
+	/**
+	* @param params - Parsed route parameters
+	*/
+	params;
+	route;
+	constructor(init) {
+		Object.assign(this, init);
+	}
+};
+
+//#endregion
+//#region src/Route.ts
+var Route = class {
+	ctx;
+	body = {};
+	query = {};
+	params = {};
+	clearRequest;
+	methods;
+	path;
+	handler;
+	middlewares;
+	constructor(methods, path, handler, middlewares = []) {
+		this.methods = methods;
+		this.path = path;
+		this.handler = handler;
+		this.middlewares = middlewares;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ClearRequest', {
+  enumerable: true,
+  get: function () {
+    return ClearRequest;
+  }
+});
+Object.defineProperty(exports, 'Route', {
+  enumerable: true,
+  get: function () {
+    return Route;
+  }
+});

package/dist/Route-BtmoiYq5.mjs

@@ -0,0 +1,42 @@
+//#region src/ClearRequest.ts
+var ClearRequest = class {
+	/**
+	* @param body - Parsed request body
+	*/
+	body;
+	/**
+	* @param query - Parsed query parameters
+	*/
+	query;
+	/**
+	* @param params - Parsed route parameters
+	*/
+	params;
+	route;
+	constructor(init) {
+		Object.assign(this, init);
+	}
+};
+
+//#endregion
+//#region src/Route.ts
+var Route = class {
+	ctx;
+	body = {};
+	query = {};
+	params = {};
+	clearRequest;
+	methods;
+	path;
+	handler;
+	middlewares;
+	constructor(methods, path, handler, middlewares = []) {
+		this.methods = methods;
+		this.path = path;
+		this.handler = handler;
+		this.middlewares = middlewares;
+	}
+};
+
+//#endregion
+export { ClearRequest as n, Route as t };

package/dist/express/index.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_Route = require('../Route-97p-tEbS.cjs');
 
 //#region src/express/router.ts
 /**
@@ -8,7 +9,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 * @author 3m1n3nc3
 * @repository https://github.com/toneflix/clear-router
 */
-var Router = class {
+var Router = class Router {
 	/**
 	* All registered routes
 	*/
@@ -43,16 +44,11 @@ var Router = class {
 	static add(methods, path, handler, middlewares) {
 		const methodArray = Array.isArray(methods) ? methods : [methods];
 		const fullPath = this.normalizePath(`${this.prefix}/${path}`);
-		this.routes.push({
-			methods: methodArray,
-			path: fullPath,
-			handler,
-			middlewares: [
-				...this.globalMiddlewares,
-				...this.groupMiddlewares,
-				...middlewares || []
-			]
-		});
+		this.routes.push(new require_Route.Route(methodArray, fullPath, handler, [
+			...this.globalMiddlewares,
+			...this.groupMiddlewares,
+			...middlewares || []
+		]));
 	}
 	/**
 	* Register RESTful API resource routes for a controller with optional action filtering
@@ -200,13 +196,20 @@ var Router = class {
 	static async apply(router) {
 		for (const route of this.routes) {
 			let handlerFunction = null;
+			let instance = null;
 			try {
-				if (typeof route.handler === "function") handlerFunction = route.handler;
+				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 (typeof Controller === "function" && typeof Controller[method] === "function") handlerFunction = Controller[method].bind(Controller);
-					else if (typeof Controller === "function") {
-						const instance = new Controller();
+					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}`);
@@ -227,16 +230,19 @@ var Router = class {
 					"head"
 				].includes(method)) {
 					const error = /* @__PURE__ */ new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-					console.error(`[ROUTES]`, error.message);
+					console.error("[ROUTES]", error.message);
 					throw error;
 				}
 				router[method](route.path, ...route.middlewares || [], async (req, res, next) => {
 					try {
-						const result = handlerFunction({
+						const ctx = {
 							req,
 							res,
 							next
-						});
+						};
+						const inst = instance ?? route;
+						await Router.bindRequestToInstance(ctx, inst, route);
+						const result = handlerFunction(ctx, inst.clearRequest);
 						await Promise.resolve(result);
 					} catch (error) {
 						next(error);
@@ -245,6 +251,20 @@ var Router = class {
 			}
 		}
 	}
+	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 require_Route.ClearRequest({
+			ctx,
+			route,
+			body: instance.body,
+			query: instance.query,
+			params: instance.params
+		});
+	}
 };
 
 //#endregion

package/dist/express/index.d.cts

@@ -1,28 +1,6 @@
-import { i as RouteInfo, n as ControllerHandler, r as HttpMethod, t as ControllerAction } from "../basic-BCxhZ1Wd.cjs";
-import { NextFunction, Request, Response, Router as Router$1 } from "express";
+import { d as RouteInfo, i as Route, l as ControllerAction, n as HttpContext, r as Middleware, t as Handler, u as HttpMethod } from "../express-sjYra4oE.cjs";
+import { Router as Router$1 } from "express";
 
-//#region types/express.d.ts
-/**
- * HTTP context passed to route handlers
- */
-interface HttpContext {
-  req: Request;
-  res: Response;
-  next: NextFunction;
-}
-/**
- * Route handler function type
- */
-type RouteHandler = (ctx: HttpContext) => any | Promise<any>;
-/**
- * Handler can be either a function or controller reference
- */
-type Handler = RouteHandler | ControllerHandler;
-/**
- * Middleware function type
- */
-type Middleware = (req: Request, res: Response, next: NextFunction) => any | Promise<any>;
-//#endregion
 //#region src/express/router.d.ts
 /**
  * @class clear-router
@@ -35,12 +13,7 @@ declare class Router {
   /**
    * All registered routes
    */
-  static routes: Array<{
-    methods: HttpMethod[];
-    path: string;
-    handler: Handler;
-    middlewares: Middleware[];
-  }>;
+  static routes: Array<Route<HttpContext, Middleware>>;
   /**
    * Current route prefix
    */
@@ -154,6 +127,7 @@ declare class Router {
    */
   static apply(router: Router$1): void;
   static apply(router: Router$1): Promise<void>;
+  private static bindRequestToInstance;
 }
 //#endregion
 export { Router };

package/dist/express/index.d.mts

@@ -1,28 +1,6 @@
-import { i as RouteInfo, n as ControllerHandler, r as HttpMethod, t as ControllerAction } from "../basic-POMY6a76.mjs";
-import { NextFunction, Request, Response, Router as Router$1 } from "express";
+import { d as RouteInfo, i as Route, l as ControllerAction, n as HttpContext, r as Middleware, t as Handler, u as HttpMethod } from "../express-WiUTZlHA.mjs";
+import { Router as Router$1 } from "express";
 
-//#region types/express.d.ts
-/**
- * HTTP context passed to route handlers
- */
-interface HttpContext {
-  req: Request;
-  res: Response;
-  next: NextFunction;
-}
-/**
- * Route handler function type
- */
-type RouteHandler = (ctx: HttpContext) => any | Promise<any>;
-/**
- * Handler can be either a function or controller reference
- */
-type Handler = RouteHandler | ControllerHandler;
-/**
- * Middleware function type
- */
-type Middleware = (req: Request, res: Response, next: NextFunction) => any | Promise<any>;
-//#endregion
 //#region src/express/router.d.ts
 /**
  * @class clear-router
@@ -35,12 +13,7 @@ declare class Router {
   /**
    * All registered routes
    */
-  static routes: Array<{
-    methods: HttpMethod[];
-    path: string;
-    handler: Handler;
-    middlewares: Middleware[];
-  }>;
+  static routes: Array<Route<HttpContext, Middleware>>;
   /**
    * Current route prefix
    */
@@ -154,6 +127,7 @@ declare class Router {
    */
   static apply(router: Router$1): void;
   static apply(router: Router$1): Promise<void>;
+  private static bindRequestToInstance;
 }
 //#endregion
 export { Router };

package/dist/express/index.mjs

@@ -1,3 +1,5 @@
+import { n as ClearRequest, t as Route } from "../Route-BtmoiYq5.mjs";
+
 //#region src/express/router.ts
 /**
 * @class clear-router
@@ -6,7 +8,7 @@
 * @author 3m1n3nc3
 * @repository https://github.com/toneflix/clear-router
 */
-var Router = class {
+var Router = class Router {
 	/**
 	* All registered routes
 	*/
@@ -41,16 +43,11 @@ var Router = class {
 	static add(methods, path, handler, middlewares) {
 		const methodArray = Array.isArray(methods) ? methods : [methods];
 		const fullPath = this.normalizePath(`${this.prefix}/${path}`);
-		this.routes.push({
-			methods: methodArray,
-			path: fullPath,
-			handler,
-			middlewares: [
-				...this.globalMiddlewares,
-				...this.groupMiddlewares,
-				...middlewares || []
-			]
-		});
+		this.routes.push(new Route(methodArray, fullPath, handler, [
+			...this.globalMiddlewares,
+			...this.groupMiddlewares,
+			...middlewares || []
+		]));
 	}
 	/**
 	* Register RESTful API resource routes for a controller with optional action filtering
@@ -198,13 +195,20 @@ var Router = class {
 	static async apply(router) {
 		for (const route of this.routes) {
 			let handlerFunction = null;
+			let instance = null;
 			try {
-				if (typeof route.handler === "function") handlerFunction = route.handler;
+				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 (typeof Controller === "function" && typeof Controller[method] === "function") handlerFunction = Controller[method].bind(Controller);
-					else if (typeof Controller === "function") {
-						const instance = new Controller();
+					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}`);
@@ -225,16 +229,19 @@ var Router = class {
 					"head"
 				].includes(method)) {
 					const error = /* @__PURE__ */ new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-					console.error(`[ROUTES]`, error.message);
+					console.error("[ROUTES]", error.message);
 					throw error;
 				}
 				router[method](route.path, ...route.middlewares || [], async (req, res, next) => {
 					try {
-						const result = handlerFunction({
+						const ctx = {
 							req,
 							res,
 							next
-						});
+						};
+						const inst = instance ?? route;
+						await Router.bindRequestToInstance(ctx, inst, route);
+						const result = handlerFunction(ctx, inst.clearRequest);
 						await Promise.resolve(result);
 					} catch (error) {
 						next(error);
@@ -243,6 +250,20 @@ var Router = class {
 			}
 		}
 	}
+	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

package/dist/express-WiUTZlHA.d.mts

@@ -0,0 +1,123 @@
+import { H3, H3Event, Middleware as Middleware$1, TypedServerRequest } from "h3";
+import { NextFunction, Request, Response as Response$1 } from "express";
+
+//#region types/basic.d.ts
+/**
+ * Controller method reference
+ */
+type ControllerHandler = [any, string];
+/**
+ * HTTP methods supported by the router
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+/**
+ * Route information object
+ */
+interface RouteInfo {
+  methods: HttpMethod[];
+  path: string;
+  middlewareCount: number;
+  handlerType: 'function' | 'controller';
+}
+/**
+ * Common controller action names
+ */
+type ControllerAction = 'index' | 'show' | 'create' | 'update' | 'destroy';
+/**
+ * Generic Object type for request data
+ */
+type RequestData = Record<string, any>;
+//#endregion
+//#region types/h3.d.ts
+type H3App = Omit<H3['fetch'], 'fetch'> & {
+  fetch: (request: TypedServerRequest) => Promise<Response>;
+};
+/**
+ * HTTP context passed to route handlers
+ */
+type HttpContext$1 = H3Event & {};
+/**
+ * Route handler function type
+ */
+type RouteHandler$1 = (
+/**
+ * H3 event context
+ */
+
+ctx: HttpContext$1,
+/**
+ * ClearRequest instance
+ */
+
+req: ClearRequest) => any | Promise<any>;
+/**
+ * Handler can be either a function or controller reference
+ */
+type Handler$1 = RouteHandler$1 | ControllerHandler;
+//#endregion
+//#region src/Route.d.ts
+declare class Route<X = any, M = Middleware$1 | Middleware> {
+  ctx: X;
+  body: RequestData;
+  query: RequestData;
+  params: RequestData;
+  clearRequest: ClearRequest;
+  methods: HttpMethod[];
+  path: string;
+  handler: Handler$1;
+  middlewares: M[];
+  constructor(methods: HttpMethod[], path: string, handler: Handler$1, middlewares?: M[]);
+}
+//#endregion
+//#region src/ClearRequest.d.ts
+declare class ClearRequest<X = any, M = Middleware$1 | Middleware> {
+  [key: string]: any;
+  /**
+   * @param body - Parsed request body
+   */
+  body: RequestData;
+  /**
+   * @param query - Parsed query parameters
+   */
+  query: RequestData;
+  /**
+   * @param params - Parsed route parameters
+   */
+  params: RequestData;
+  route: Route<X, M>;
+  constructor(init?: Partial<ClearRequest>);
+}
+//#endregion
+//#region types/express.d.ts
+/**
+ * HTTP context passed to route handlers
+ */
+interface HttpContext {
+  req: Request;
+  res: Response$1;
+  next: NextFunction;
+}
+/**
+ * Route handler function type
+ */
+type RouteHandler = (
+/**
+ * Express context object containing req, res, and next
+ */
+
+ctx: HttpContext,
+/**
+ * ClearRequest instance
+ */
+
+req: ClearRequest) => any | Promise<any>;
+/**
+ * Handler can be either a function or controller reference
+ */
+type Handler = RouteHandler | ControllerHandler;
+/**
+ * Middleware function type
+ */
+type Middleware = (req: Request, res: Response$1, next: NextFunction) => any | Promise<any>;
+//#endregion
+export { H3App as a, Middleware$1 as c, RouteInfo as d, Route as i, ControllerAction as l, HttpContext as n, Handler$1 as o, Middleware as r, HttpContext$1 as s, Handler as t, HttpMethod as u };

package/dist/express-sjYra4oE.d.cts

@@ -0,0 +1,123 @@
+import { NextFunction, Request, Response as Response$1 } from "express";
+import { H3, H3Event, Middleware as Middleware$1, TypedServerRequest } from "h3";
+
+//#region types/basic.d.ts
+/**
+ * Controller method reference
+ */
+type ControllerHandler = [any, string];
+/**
+ * HTTP methods supported by the router
+ */
+type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+/**
+ * Route information object
+ */
+interface RouteInfo {
+  methods: HttpMethod[];
+  path: string;
+  middlewareCount: number;
+  handlerType: 'function' | 'controller';
+}
+/**
+ * Common controller action names
+ */
+type ControllerAction = 'index' | 'show' | 'create' | 'update' | 'destroy';
+/**
+ * Generic Object type for request data
+ */
+type RequestData = Record<string, any>;
+//#endregion
+//#region types/h3.d.ts
+type H3App = Omit<H3['fetch'], 'fetch'> & {
+  fetch: (request: TypedServerRequest) => Promise<Response>;
+};
+/**
+ * HTTP context passed to route handlers
+ */
+type HttpContext$1 = H3Event & {};
+/**
+ * Route handler function type
+ */
+type RouteHandler$1 = (
+/**
+ * H3 event context
+ */
+
+ctx: HttpContext$1,
+/**
+ * ClearRequest instance
+ */
+
+req: ClearRequest) => any | Promise<any>;
+/**
+ * Handler can be either a function or controller reference
+ */
+type Handler$1 = RouteHandler$1 | ControllerHandler;
+//#endregion
+//#region src/Route.d.ts
+declare class Route<X = any, M = Middleware$1 | Middleware> {
+  ctx: X;
+  body: RequestData;
+  query: RequestData;
+  params: RequestData;
+  clearRequest: ClearRequest;
+  methods: HttpMethod[];
+  path: string;
+  handler: Handler$1;
+  middlewares: M[];
+  constructor(methods: HttpMethod[], path: string, handler: Handler$1, middlewares?: M[]);
+}
+//#endregion
+//#region src/ClearRequest.d.ts
+declare class ClearRequest<X = any, M = Middleware$1 | Middleware> {
+  [key: string]: any;
+  /**
+   * @param body - Parsed request body
+   */
+  body: RequestData;
+  /**
+   * @param query - Parsed query parameters
+   */
+  query: RequestData;
+  /**
+   * @param params - Parsed route parameters
+   */
+  params: RequestData;
+  route: Route<X, M>;
+  constructor(init?: Partial<ClearRequest>);
+}
+//#endregion
+//#region types/express.d.ts
+/**
+ * HTTP context passed to route handlers
+ */
+interface HttpContext {
+  req: Request;
+  res: Response$1;
+  next: NextFunction;
+}
+/**
+ * Route handler function type
+ */
+type RouteHandler = (
+/**
+ * Express context object containing req, res, and next
+ */
+
+ctx: HttpContext,
+/**
+ * ClearRequest instance
+ */
+
+req: ClearRequest) => any | Promise<any>;
+/**
+ * Handler can be either a function or controller reference
+ */
+type Handler = RouteHandler | ControllerHandler;
+/**
+ * Middleware function type
+ */
+type Middleware = (req: Request, res: Response$1, next: NextFunction) => any | Promise<any>;
+//#endregion
+export { H3App as a, Middleware$1 as c, RouteInfo as d, Route as i, ControllerAction as l, HttpContext as n, Handler$1 as o, Middleware as r, HttpContext$1 as s, Handler as t, HttpMethod as u };

package/dist/h3/index.cjs

@@ -1,4 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_Route = require('../Route-97p-tEbS.cjs');
+let h3 = require("h3");
 
 //#region src/h3/router.ts
 /**
@@ -7,7 +9,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 * @author 3m1n3nc3
 * @repository https://github.com/toneflix/clear-router
 */
-var Router = class {
+var Router = class Router {
 	/**
 	* All registered routes
 	*/
@@ -42,16 +44,11 @@ var Router = class {
 	static add(methods, path, handler, middlewares) {
 		const methodArray = Array.isArray(methods) ? methods : [methods];
 		const fullPath = this.normalizePath(`${this.prefix}/${path}`);
-		this.routes.push({
-			methods: methodArray,
-			path: fullPath,
-			handler,
-			middlewares: [
-				...this.globalMiddlewares,
-				...this.groupMiddlewares,
-				...middlewares || []
-			]
-		});
+		this.routes.push(new require_Route.Route(methodArray, fullPath, handler, [
+			...this.globalMiddlewares,
+			...this.groupMiddlewares,
+			...middlewares || []
+		]));
 	}
 	/**
 	* Register RESTful API resource routes for a controller with optional action filtering
@@ -206,13 +203,20 @@ var Router = class {
 	static apply(app) {
 		for (const route of this.routes) {
 			let handlerFunction = null;
+			let instance = null;
 			try {
-				if (typeof route.handler === "function") handlerFunction = route.handler;
+				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 (typeof Controller === "function" && typeof Controller[method] === "function") handlerFunction = Controller[method].bind(Controller);
-					else if (typeof Controller === "function") {
-						const instance = new Controller();
+					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}`);
@@ -233,12 +237,15 @@ var Router = class {
 					"head"
 				].includes(method)) {
 					const error = /* @__PURE__ */ new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-					console.error(`[ROUTES]`, error.message);
+					console.error("[ROUTES]", error.message);
 					throw error;
 				}
 				app[method](route.path, async (event) => {
 					try {
-						const result = handlerFunction(event);
+						const ctx = event;
+						const inst = instance ?? route;
+						await Router.bindRequestToInstance(ctx, inst, route);
+						const result = handlerFunction(ctx, inst.clearRequest);
 						return await Promise.resolve(result);
 					} catch (error) {
 						return error;
@@ -248,6 +255,20 @@ var Router = class {
 		}
 		return app;
 	}
+	static async bindRequestToInstance(ctx, instance, route) {
+		if (!instance) return;
+		instance.ctx = ctx;
+		instance.body = await (0, h3.readBody)(ctx) ?? {};
+		instance.query = (0, h3.getQuery)(ctx);
+		instance.params = (0, h3.getRouterParams)(ctx, { decode: true });
+		instance.clearRequest = new require_Route.ClearRequest({
+			ctx,
+			route,
+			body: instance.body,
+			query: instance.query,
+			params: instance.params
+		});
+	}
 };
 
 //#endregion

package/dist/h3/index.d.cts

@@ -1,23 +1,6 @@
-import { i as RouteInfo, n as ControllerHandler, r as HttpMethod, t as ControllerAction } from "../basic-BCxhZ1Wd.cjs";
-import { H3, H3Event, Middleware, TypedServerRequest } from "h3";
+import { a as H3App, c as Middleware, d as RouteInfo, i as Route, l as ControllerAction, o as Handler, s as HttpContext, u as HttpMethod } from "../express-sjYra4oE.cjs";
+import { H3 } from "h3";
 
-//#region types/h3.d.ts
-type H3App = Omit<H3['fetch'], 'fetch'> & {
-  fetch: (request: TypedServerRequest) => Promise<Response>;
-};
-/**
- * HTTP context passed to route handlers
- */
-interface HttpContext extends H3Event {}
-/**
- * Route handler function type
- */
-type RouteHandler = (ctx: HttpContext) => any | Promise<any>;
-/**
- * Handler can be either a function or controller reference
- */
-type Handler = RouteHandler | ControllerHandler;
-//#endregion
 //#region src/h3/router.d.ts
 /**
  * @class clear-router
@@ -29,12 +12,7 @@ declare class Router {
   /**
    * All registered routes
    */
-  static routes: Array<{
-    methods: HttpMethod[];
-    path: string;
-    handler: Handler;
-    middlewares: Middleware[];
-  }>;
+  static routes: Array<Route<HttpContext, Middleware>>;
   /**
    * Current route prefix
    */
@@ -147,6 +125,7 @@ declare class Router {
    * @param app - H3 app instance
    */
   static apply(app: H3): H3App;
+  private static bindRequestToInstance;
 }
 //#endregion
 export { Router };

package/dist/h3/index.d.mts

@@ -1,23 +1,6 @@
-import { i as RouteInfo, n as ControllerHandler, r as HttpMethod, t as ControllerAction } from "../basic-POMY6a76.mjs";
-import { H3, H3Event, Middleware, TypedServerRequest } from "h3";
+import { a as H3App, c as Middleware, d as RouteInfo, i as Route, l as ControllerAction, o as Handler, s as HttpContext, u as HttpMethod } from "../express-WiUTZlHA.mjs";
+import { H3 } from "h3";
 
-//#region types/h3.d.ts
-type H3App = Omit<H3['fetch'], 'fetch'> & {
-  fetch: (request: TypedServerRequest) => Promise<Response>;
-};
-/**
- * HTTP context passed to route handlers
- */
-interface HttpContext extends H3Event {}
-/**
- * Route handler function type
- */
-type RouteHandler = (ctx: HttpContext) => any | Promise<any>;
-/**
- * Handler can be either a function or controller reference
- */
-type Handler = RouteHandler | ControllerHandler;
-//#endregion
 //#region src/h3/router.d.ts
 /**
  * @class clear-router
@@ -29,12 +12,7 @@ declare class Router {
   /**
    * All registered routes
    */
-  static routes: Array<{
-    methods: HttpMethod[];
-    path: string;
-    handler: Handler;
-    middlewares: Middleware[];
-  }>;
+  static routes: Array<Route<HttpContext, Middleware>>;
   /**
    * Current route prefix
    */
@@ -147,6 +125,7 @@ declare class Router {
    * @param app - H3 app instance
    */
   static apply(app: H3): H3App;
+  private static bindRequestToInstance;
 }
 //#endregion
 export { Router };

package/dist/h3/index.mjs

@@ -1,3 +1,6 @@
+import { n as ClearRequest, t as Route } from "../Route-BtmoiYq5.mjs";
+import { getQuery, getRouterParams, readBody } from "h3";
+
 //#region src/h3/router.ts
 /**
 * @class clear-router
@@ -5,7 +8,7 @@
 * @author 3m1n3nc3
 * @repository https://github.com/toneflix/clear-router
 */
-var Router = class {
+var Router = class Router {
 	/**
 	* All registered routes
 	*/
@@ -40,16 +43,11 @@ var Router = class {
 	static add(methods, path, handler, middlewares) {
 		const methodArray = Array.isArray(methods) ? methods : [methods];
 		const fullPath = this.normalizePath(`${this.prefix}/${path}`);
-		this.routes.push({
-			methods: methodArray,
-			path: fullPath,
-			handler,
-			middlewares: [
-				...this.globalMiddlewares,
-				...this.groupMiddlewares,
-				...middlewares || []
-			]
-		});
+		this.routes.push(new Route(methodArray, fullPath, handler, [
+			...this.globalMiddlewares,
+			...this.groupMiddlewares,
+			...middlewares || []
+		]));
 	}
 	/**
 	* Register RESTful API resource routes for a controller with optional action filtering
@@ -204,13 +202,20 @@ var Router = class {
 	static apply(app) {
 		for (const route of this.routes) {
 			let handlerFunction = null;
+			let instance = null;
 			try {
-				if (typeof route.handler === "function") handlerFunction = route.handler;
+				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 (typeof Controller === "function" && typeof Controller[method] === "function") handlerFunction = Controller[method].bind(Controller);
-					else if (typeof Controller === "function") {
-						const instance = new Controller();
+					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}`);
@@ -231,12 +236,15 @@ var Router = class {
 					"head"
 				].includes(method)) {
 					const error = /* @__PURE__ */ new Error(`Invalid HTTP method: ${method} for route: ${route.path}`);
-					console.error(`[ROUTES]`, error.message);
+					console.error("[ROUTES]", error.message);
 					throw error;
 				}
 				app[method](route.path, async (event) => {
 					try {
-						const result = handlerFunction(event);
+						const ctx = event;
+						const inst = instance ?? route;
+						await Router.bindRequestToInstance(ctx, inst, route);
+						const result = handlerFunction(ctx, inst.clearRequest);
 						return await Promise.resolve(result);
 					} catch (error) {
 						return error;
@@ -246,6 +254,20 @@ var Router = class {
 		}
 		return app;
 	}
+	static async bindRequestToInstance(ctx, instance, route) {
+		if (!instance) return;
+		instance.ctx = ctx;
+		instance.body = await readBody(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

package/dist/src/ClearRequest.d.mts

@@ -0,0 +1,25 @@
+import { RequestData } from "../types/basic.mjs";
+import { Middleware } from "../types/h3.mjs";
+import { Route } from "./Route.mjs";
+import { Middleware as Middleware$1 } from "../types/express.mjs";
+
+//#region src/ClearRequest.d.ts
+declare class ClearRequest<X = any, M = Middleware | Middleware$1> {
+  [key: string]: any;
+  /**
+   * @param body - Parsed request body
+   */
+  body: RequestData;
+  /**
+   * @param query - Parsed query parameters
+   */
+  query: RequestData;
+  /**
+   * @param params - Parsed route parameters
+   */
+  params: RequestData;
+  route: Route<X, M>;
+  constructor(init?: Partial<ClearRequest>);
+}
+//#endregion
+export { ClearRequest };

package/dist/src/Route.d.mts

@@ -0,0 +1,20 @@
+import { HttpMethod, RequestData } from "../types/basic.mjs";
+import { Handler, Middleware } from "../types/h3.mjs";
+import { ClearRequest } from "./ClearRequest.mjs";
+import { Middleware as Middleware$1 } from "../types/express.mjs";
+
+//#region src/Route.d.ts
+declare class Route<X = any, M = Middleware | Middleware$1> {
+  ctx: X;
+  body: RequestData;
+  query: RequestData;
+  params: RequestData;
+  clearRequest: ClearRequest;
+  methods: HttpMethod[];
+  path: string;
+  handler: Handler;
+  middlewares: M[];
+  constructor(methods: HttpMethod[], path: string, handler: Handler, middlewares?: M[]);
+}
+//#endregion
+export { Route };

package/dist/types/basic.d.mts

@@ -20,5 +20,9 @@ interface RouteInfo {
  * Common controller action names
  */
 type ControllerAction = 'index' | 'show' | 'create' | 'update' | 'destroy';
+/**
+ * Generic Object type for request data
+ */
+type RequestData = Record<string, any>;
 //#endregion
-export { ControllerAction, ControllerHandler, HttpMethod, RouteInfo };
+export { ControllerAction, ControllerHandler, HttpMethod, RequestData, RouteInfo };

package/dist/types/express.d.mts

@@ -1,4 +1,5 @@
 import { ControllerHandler } from "./basic.mjs";
+import { ClearRequest } from "../src/ClearRequest.mjs";
 import { NextFunction, Request, Response } from "express";
 
 //#region types/express.d.ts
@@ -13,7 +14,17 @@ interface HttpContext {
 /**
  * Route handler function type
  */
-type RouteHandler = (ctx: HttpContext) => any | Promise<any>;
+type RouteHandler = (
+/**
+ * Express context object containing req, res, and next
+ */
+
+ctx: HttpContext,
+/**
+ * ClearRequest instance
+ */
+
+req: ClearRequest) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */

package/dist/types/h3.d.mts

@@ -1,4 +1,5 @@
 import { ControllerHandler } from "./basic.mjs";
+import { ClearRequest } from "../src/ClearRequest.mjs";
 import { H3, H3Event, Middleware, TypedServerRequest } from "h3";
 
 //#region types/h3.d.ts
@@ -9,11 +10,21 @@ type MaybePromise<T = unknown> = T | Promise<T>;
 /**
  * HTTP context passed to route handlers
  */
-interface HttpContext extends H3Event {}
+type HttpContext = H3Event & {};
 /**
  * Route handler function type
  */
-type RouteHandler = (ctx: HttpContext) => any | Promise<any>;
+type RouteHandler = (
+/**
+ * H3 event context
+ */
+
+ctx: HttpContext,
+/**
+ * ClearRequest instance
+ */
+
+req: ClearRequest) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clear-router",
-  "version": "2.0.8",
+  "version": "2.1.1",
   "description": "Laravel-style routing system for Express.js and H3, with CommonJS, ESM, and TypeScript support",
   "keywords": [
     "h3",
@@ -63,21 +63,26 @@
     }
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@eslint/markdown": "^7.5.1",
     "@types/express": "^4.17.21",
     "@types/node": "^20.10.6",
     "@types/supertest": "^6.0.3",
+    "eslint": "^10.0.2",
     "supertest": "^7.1.1",
     "tsdown": "^0.20.3",
     "tsx": "^4.21.0",
     "typescript": "^5.3.3",
+    "typescript-eslint": "^8.56.1",
     "vite-tsconfig-paths": "^6.1.1",
     "vitest": "^4.0.18"
   },
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=20.0.0"
   },
   "scripts": {
-    "test": "pnpm test:esm && pnpm test:ts",
+    "test": "vitest",
+    "lint": "eslint",
     "test:esm": "vitest tests/esm.test.ts",
     "test:ts": "vitest tests/typescript.test.ts",
     "example": "tsx example/express/index.ts",

package/dist/basic-BCxhZ1Wd.d.cts

@@ -1,24 +0,0 @@
-//#region types/basic.d.ts
-/**
- * Controller method reference
- */
-type ControllerHandler = [any, string];
-/**
- * HTTP methods supported by the router
- */
-type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
-/**
- * Route information object
- */
-interface RouteInfo {
-  methods: HttpMethod[];
-  path: string;
-  middlewareCount: number;
-  handlerType: 'function' | 'controller';
-}
-/**
- * Common controller action names
- */
-type ControllerAction = 'index' | 'show' | 'create' | 'update' | 'destroy';
-//#endregion
-export { RouteInfo as i, ControllerHandler as n, HttpMethod as r, ControllerAction as t };

package/dist/basic-POMY6a76.d.mts

@@ -1,24 +0,0 @@
-//#region types/basic.d.ts
-/**
- * Controller method reference
- */
-type ControllerHandler = [any, string];
-/**
- * HTTP methods supported by the router
- */
-type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
-/**
- * Route information object
- */
-interface RouteInfo {
-  methods: HttpMethod[];
-  path: string;
-  middlewareCount: number;
-  handlerType: 'function' | 'controller';
-}
-/**
- * Common controller action names
- */
-type ControllerAction = 'index' | 'show' | 'create' | 'update' | 'destroy';
-//#endregion
-export { RouteInfo as i, ControllerHandler as n, HttpMethod as r, ControllerAction as t };