clear-router 2.5.4 → 2.5.6

package/dist/{router-CHg0pZUO.cjs → router-CU4V1kX0.cjs}

@@ -1,26 +1,6 @@
+const require_bindings = require('./bindings-DvV2DXWi.cjs');
 let node_async_hooks = require("node:async_hooks");
 
-//#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;
@@ -60,6 +40,41 @@ var CoreRouter = class {
 	static routerStateNamespace = "clear-router:core";
 	static stateStoreKey = Symbol.for("clear-router:router-state");
 	static stateBoundKey = Symbol.for("clear-router:router-state-bound");
+	static defaultConfigKey = Symbol.for("clear-router:default-config");
+	static pluginStoreKey = Symbol.for("clear-router:plugins");
+	static createBaseConfig() {
+		return {
+			methodOverride: {
+				enabled: true,
+				bodyKeys: ["_method"],
+				headerKeys: ["x-http-method"]
+			},
+			container: {
+				enabled: false,
+				autoDiscover: false
+			}
+		};
+	}
+	static mergeConfig(target, source) {
+		if (!source) return target;
+		if (source.methodOverride) target.methodOverride = {
+			...target.methodOverride || {},
+			...source.methodOverride
+		};
+		if (source.container) target.container = {
+			...target.container || {},
+			...source.container
+		};
+		return target;
+	}
+	static getDefaultConfig() {
+		const g = globalThis;
+		if (!g[this.defaultConfigKey]) g[this.defaultConfigKey] = this.createBaseConfig();
+		return {
+			methodOverride: { ...g[this.defaultConfigKey].methodOverride },
+			container: { ...g[this.defaultConfigKey].container }
+		};
+	}
 	static resolveStateNamespace() {
 		return String(this.routerStateNamespace || this.name || "clear-router:core");
 	}
@@ -68,13 +83,14 @@ var CoreRouter = class {
 		if (!g[this.stateStoreKey]) g[this.stateStoreKey] = Object.create(null);
 		return g[this.stateStoreKey];
 	}
+	static getPluginStore() {
+		const g = globalThis;
+		if (!g[this.pluginStoreKey]) g[this.pluginStoreKey] = /* @__PURE__ */ new Set();
+		return g[this.pluginStoreKey];
+	}
 	static createDefaultState() {
 		return {
-			config: { methodOverride: {
-				enabled: true,
-				bodyKeys: ["_method"],
-				headerKeys: ["x-http-method"]
-			} },
+			config: this.getDefaultConfig(),
 			groupContext: new node_async_hooks.AsyncLocalStorage(),
 			routes: [],
 			routesByPathMethod: {},
@@ -151,11 +167,47 @@ var CoreRouter = class {
 			}
 		};
 	}
-	static config = { methodOverride: {
-		enabled: true,
-		bodyKeys: ["_method"],
-		headerKeys: ["x-http-method"]
-	} };
+	static config = {
+		methodOverride: {
+			enabled: true,
+			bodyKeys: ["_method"],
+			headerKeys: ["x-http-method"]
+		},
+		container: {
+			enabled: false,
+			autoDiscover: false
+		}
+	};
+	static configureDefaults(options) {
+		const g = globalThis;
+		const defaults = this.mergeConfig(g[this.defaultConfigKey] || this.createBaseConfig(), options);
+		g[this.defaultConfigKey] = defaults;
+		const store = this.getStateStore();
+		for (const state of Object.values(store)) state.config = this.mergeConfig(state.config || this.createBaseConfig(), options);
+	}
+	/**
+	* Use a registered plugin
+	* 
+	* @param this 
+	* @param plugin 
+	* @param options 
+	* @returns 
+	*/
+	static use(plugin, options) {
+		const name = typeof plugin === "function" ? plugin.name : plugin.name;
+		const store = this.getPluginStore();
+		if (name && store.has(name)) return;
+		const ctx = {
+			container: require_bindings.Container,
+			bind: require_bindings.Container.bind.bind(require_bindings.Container),
+			configure: this.configure.bind(this),
+			configureDefaults: this.configureDefaults.bind(this),
+			options
+		};
+		if (typeof plugin === "function") plugin(ctx);
+		else plugin.setup(ctx);
+		if (name) store.add(name);
+	}
 	static groupContext = new node_async_hooks.AsyncLocalStorage();
 	static routes = [];
 	static routesByPathMethod = {};
@@ -197,11 +249,12 @@ var CoreRouter = class {
 	*/
 	static configure(options) {
 		this.ensureState();
-		if (!this.config.methodOverride) this.config.methodOverride = {
-			enabled: true,
-			bodyKeys: ["_method"],
-			headerKeys: ["x-http-method"]
-		};
+		this.config = this.mergeConfig(this.getDefaultConfig(), this.config);
+		const container = options?.container;
+		if (container) {
+			if (typeof container.enabled === "boolean") this.config.container.enabled = container.enabled;
+			if (typeof container.autoDiscover === "boolean") this.config.container.autoDiscover = container.autoDiscover;
+		}
 		const override = options?.methodOverride;
 		if (!override) return;
 		if (typeof override.enabled === "boolean") this.config.methodOverride.enabled = override.enabled;
@@ -438,36 +491,94 @@ var CoreRouter = class {
 	static resolveHandler(route) {
 		let handlerFunction;
 		let instance = null;
-		if (typeof route.handler === "function") handlerFunction = route.handler.bind(route);
-		else if (Array.isArray(route.handler) && route.handler.length === 2) {
+		let bindingTarget;
+		let bindingMethod;
+		let bindingHandler;
+		let bindingMetadata;
+		if (typeof route.handler === "function") {
+			handlerFunction = route.handler.bind(route);
+			bindingTarget = route.handler;
+			bindingHandler = route.handler;
+		} else if (Array.isArray(route.handler) && route.handler.length === 2) {
 			const [ControllerType, method] = route.handler;
 			if (["function", "object"].includes(typeof ControllerType) && typeof ControllerType[method] === "function") {
 				instance = ControllerType;
 				handlerFunction = ControllerType[method].bind(ControllerType);
+				bindingTarget = ControllerType;
+				bindingMethod = method;
+				bindingHandler = ControllerType[method];
+				bindingMetadata = ControllerType[Symbol.metadata];
 			} else if (typeof ControllerType === "function") {
 				instance = new ControllerType();
-				if (typeof instance[method] === "function") handlerFunction = instance[method].bind(instance);
-				else throw new Error(`Method "${method}" not found in controller instance "${ControllerType.name}"`);
+				if (typeof instance[method] === "function") {
+					handlerFunction = instance[method].bind(instance);
+					bindingTarget = ControllerType.prototype;
+					bindingMethod = method;
+					bindingHandler = instance[method];
+					bindingMetadata = ControllerType[Symbol.metadata];
+				} else throw new Error(`Method "${method}" not found in controller instance "${ControllerType.name}"`);
 			} else throw new Error(`Invalid controller type for route: ${route.path}`);
 		} else throw new Error(`Invalid handler format for route: ${route.path}`);
 		return {
 			handlerFunction,
-			instance
+			instance,
+			bindingTarget,
+			bindingMethod,
+			bindingHandler,
+			bindingMetadata
 		};
 	}
+	static async callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata) {
+		if (!this.config.container?.enabled) return handlerFunction(ctx, ctx.clearRequest);
+		const metadata = require_bindings.getBindingMetadataFromTargets([
+			{
+				target: bindingTarget,
+				propertyKey: bindingMethod
+			},
+			{ target: bindingHandler },
+			{
+				target: bindingTarget,
+				propertyKey: "__class__"
+			}
+		]) ?? require_bindings.getStandardMetadata(bindingMetadata, bindingMethod) ?? require_bindings.getStandardMetadata(bindingMetadata, "__class__");
+		if (!metadata) return handlerFunction(ctx, ctx.clearRequest);
+		const designTokens = [...bindingTarget ? require_bindings.getDesignParamTypes(bindingTarget, bindingMethod) : [], ...bindingHandler ? require_bindings.getDesignParamTypes(bindingHandler) : []];
+		const tokens = metadata.tokens?.length ? metadata.tokens : designTokens;
+		if (!tokens.length) return handlerFunction(ctx, ctx.clearRequest);
+		const args = [];
+		for (const token of tokens) {
+			const resolved = await require_bindings.Container.resolve(token, ctx, Boolean(this.config.container?.autoDiscover));
+			if (typeof resolved === "undefined") return handlerFunction(ctx, ctx.clearRequest);
+			args.push(resolved);
+		}
+		return handlerFunction(...args);
+	}
 	static bindRequestToInstance(ctx, instance, route, payload) {
+		const clearRequest = ctx.clearRequest instanceof require_bindings.Request ? ctx.clearRequest : new require_bindings.Request({
+			ctx,
+			route,
+			body: payload.body,
+			query: payload.query,
+			params: payload.params,
+			method: String(payload.method || ctx.req?.method || ctx.method || "GET").toUpperCase(),
+			path: String(ctx.path || ctx.req?.path || ctx.req?.url || route.path),
+			url: String(ctx.url || ctx.req?.url || ctx.req?.originalUrl || route.path),
+			headers: ctx.req?.headers || ctx.headers || {},
+			original: ctx.req || ctx.request || ctx
+		});
+		clearRequest.ctx = ctx;
+		clearRequest.route = route;
+		clearRequest.body = payload.body;
+		clearRequest.query = payload.query;
+		clearRequest.params = payload.params;
+		ctx.clearRequest = clearRequest;
+		if (!(ctx.clearResponse instanceof require_bindings.Response)) ctx.clearResponse = new require_bindings.Response();
 		if (!instance) return;
 		instance.ctx = ctx;
 		instance.body = payload.body;
 		instance.query = payload.query;
 		instance.params = payload.params;
-		instance.clearRequest = new ClearRequest({
-			ctx,
-			route,
-			body: instance.body,
-			query: instance.query,
-			params: instance.params
-		});
+		instance.clearRequest = clearRequest;
 	}
 };
 

package/dist/{router-_w2VzMQF.d.mts → router-DCMtQ_Xi.d.mts}

@@ -1,7 +1,28 @@
+import { a as BindValue, i as BindToken, o as Container } from "./bindings-CV1e5jho.mjs";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { EventHandlerRequest, H3, H3Event, Middleware, TypedServerRequest } from "h3";
 import { NextFunction, Request, Response as Response$1 } from "express";
 
+//#region src/core/Response.d.ts
+declare class Response$2 {
+  body: any;
+  headers: Headers;
+  sent: boolean;
+  statusCode: number;
+  constructor(init?: Partial<Response$2>);
+  status(code: number): this;
+  code(code: number): this;
+  setHeader(name: string, value: string): this;
+  header(name: string, value: string): this;
+  set(name: string, value: string): this;
+  type(contentType: string): this;
+  send(body?: any): this;
+  json(body: any): this;
+  html(body: string): this;
+  text(body: string): this;
+  noContent(): this;
+}
+//#endregion
 //#region types/basic.d.ts
 /**
  * Controller method reference
@@ -30,6 +51,13 @@ interface RouterConfig {
     bodyKeys?: string[] | string; /** Keys in the request headers to check for method override */
     headerKeys?: string[] | string;
   };
+  /**
+   * Optional method binding / container resolution support. Disabled by default.
+   */
+  container?: {
+    /** Whether decorated handler parameter binding is enabled */enabled?: boolean; /** Whether unknown constructor tokens should be instantiated automatically */
+    autoDiscover?: boolean;
+  };
 }
 //#endregion
 //#region types/express.d.ts
@@ -43,6 +71,8 @@ interface HttpContext$1 {
   req: RequestWithGetBody;
   res: Response$1;
   next: NextFunction;
+  clearRequest: Request$1;
+  clearResponse: Response$2;
 }
 /**
  * Route handler function type
@@ -57,7 +87,7 @@ ctx: HttpContext$1,
  * ClearRequest instance
  */
 
-req: ClearRequest) => any | Promise<any>;
+req: Request$1) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */
@@ -80,6 +110,8 @@ type RequestlessH3Event = Omit<H3Event, 'req'>;
  */
 interface HttpContext extends RequestlessH3Event {
   req: HttpRequest;
+  clearRequest: Request$1;
+  clearResponse: Response$2;
 }
 /**
  * Route handler function type
@@ -94,7 +126,7 @@ ctx: HttpContext,
  * ClearRequest instance
  */
 
-req: ClearRequest) => any | Promise<any>;
+req: Request$1) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */
@@ -137,6 +169,43 @@ declare class ClearRequest<X = any, M = Middleware | Middleware$1> {
   constructor(init?: Partial<ClearRequest>);
 }
 //#endregion
+//#region src/core/Request.d.ts
+declare class Request$1<X = any, M = any> extends ClearRequest<X, M> {
+  original?: any;
+  method: string;
+  path: string;
+  url: string;
+  headers: Headers | Record<string, any>;
+  constructor(init?: Partial<Request$1<X, M>> & {
+    body?: RequestData;
+    query?: RequestData;
+    params?: RequestData;
+    route?: Route<X, M>;
+  });
+  getBody(): RequestData;
+  header(name: string): string;
+  param(name: string): any;
+  input(name: string): any;
+  is(method: HttpMethod | string): boolean;
+}
+//#endregion
+//#region src/core/plugins.d.ts
+type PluginSetupResult = void;
+type PluginBind = <T>(token: BindToken<T>, value: BindValue<T>) => void;
+interface ClearRouterPluginContext<Options = any> {
+  container: typeof Container;
+  bind: PluginBind;
+  configure: (options: RouterConfig) => void;
+  configureDefaults: (options: RouterConfig) => void;
+  options: Options;
+}
+interface ClearRouterPlugin<Options = any> {
+  name?: string;
+  setup: (ctx: ClearRouterPluginContext<Options>) => PluginSetupResult;
+}
+type ClearRouterPluginInput<Options = any> = ClearRouterPlugin<Options> | ((ctx: ClearRouterPluginContext<Options>) => PluginSetupResult);
+declare function definePlugin<Options = any>(plugin: ClearRouterPlugin<Options>): ClearRouterPlugin<Options>;
+//#endregion
 //#region src/Controller.d.ts
 declare abstract class Controller<X = any> {
   [x: string]: any;
@@ -158,16 +227,16 @@ declare abstract class CoreRouter {
   protected static routerStateNamespace: string;
   private static readonly stateStoreKey;
   private static readonly stateBoundKey;
+  private static readonly defaultConfigKey;
+  private static readonly pluginStoreKey;
+  protected static createBaseConfig(): RouterConfig;
+  protected static mergeConfig(target: RouterConfig, source?: RouterConfig): RouterConfig;
+  protected static getDefaultConfig(): RouterConfig;
   protected static resolveStateNamespace(this: any): string;
   protected static getStateStore(): Record<string, any>;
+  protected static getPluginStore(): Set<string>;
   protected static createDefaultState(): {
-    config: {
-      methodOverride: {
-        enabled: boolean;
-        bodyKeys: string[];
-        headerKeys: string[];
-      };
-    };
+    config: RouterConfig;
     groupContext: AsyncLocalStorage<{
       prefix: string;
       groupMiddlewares: any[];
@@ -182,6 +251,16 @@ declare abstract class CoreRouter {
   protected static bindStateAccessors(this: any): void;
   protected static createDefaultOptionsHandler(): any;
   static config: RouterConfig;
+  static configureDefaults(this: any, options?: RouterConfig): void;
+  /**
+   * Use a registered plugin
+   *
+   * @param this
+   * @param plugin
+   * @param options
+   * @returns
+   */
+  static use<Options = any>(this: any, plugin: ClearRouterPluginInput<Options>, options?: Options): void;
   protected static groupContext: AsyncLocalStorage<{
     prefix: string;
     groupMiddlewares: any[];
@@ -331,14 +410,20 @@ declare abstract class CoreRouter {
    */
   static allRoutes(this: any, type: 'method'): { [method in Uppercase<HttpMethod>]?: Array<Route<any, any, any>> };
   protected static resolveHandler(route: Route<any, any, any>): {
-    handlerFunction: ((ctx: any, req: ClearRequest) => any | Promise<any>) | null;
+    handlerFunction: ((ctx: any, req: Request$1) => any | Promise<any>) | null;
     instance: Controller<any> | null;
+    bindingTarget?: object;
+    bindingMethod?: PropertyKey;
+    bindingHandler?: object;
+    bindingMetadata?: object;
   };
+  protected static callHandler(this: any, handlerFunction: (ctx: any, req: Request$1) => any | Promise<any>, ctx: any, bindingTarget?: object, bindingMethod?: PropertyKey, bindingHandler?: object, bindingMetadata?: object): Promise<any>;
   protected static bindRequestToInstance(ctx: any, instance: Controller<any> | Route<any, any, any> | null, route: Route<any, any, any>, payload: {
     body: Record<string, any>;
     query: Record<string, any>;
     params: Record<string, any>;
+    method?: HttpMethod | string;
   }): void;
 }
 //#endregion
-export { Handler as a, Handler$1 as c, ApiResourceMiddleware as d, ControllerAction as f, H3App as i, HttpContext$1 as l, HttpMethod as m, ClearRequest as n, HttpContext as o, ControllerHandler as p, Route as r, Middleware as s, CoreRouter as t, Middleware$1 as u };
+export { ApiResourceMiddleware as _, PluginBind as a, HttpMethod as b, Request$1 as c, Handler as d, HttpContext as f, Middleware$1 as g, HttpContext$1 as h, ClearRouterPluginInput as i, Route as l, Handler$1 as m, ClearRouterPlugin as n, PluginSetupResult as o, Middleware as p, ClearRouterPluginContext as r, definePlugin as s, CoreRouter as t, H3App as u, ControllerAction as v, Response$2 as x, ControllerHandler as y };

package/dist/types/basic.d.mts

@@ -26,6 +26,13 @@ interface RouterConfig {
     bodyKeys?: string[] | string; /** Keys in the request headers to check for method override */
     headerKeys?: string[] | string;
   };
+  /**
+   * Optional method binding / container resolution support. Disabled by default.
+   */
+  container?: {
+    /** Whether decorated handler parameter binding is enabled */enabled?: boolean; /** Whether unknown constructor tokens should be instantiated automatically */
+    autoDiscover?: boolean;
+  };
 }
 //#endregion
 export { ApiResourceMiddleware, ControllerAction, ControllerHandler, HttpMethod, RequestData, RouterConfig };

package/dist/types/core/Request.d.mts

@@ -0,0 +1,25 @@
+import { HttpMethod, RequestData } from "../../types/basic.mjs";
+import { Route } from "../Route.mjs";
+import { ClearRequest } from "../ClearRequest.mjs";
+
+//#region src/core/Request.d.ts
+declare class Request<X = any, M = any> extends ClearRequest<X, M> {
+  original?: any;
+  method: string;
+  path: string;
+  url: string;
+  headers: Headers | Record<string, any>;
+  constructor(init?: Partial<Request<X, M>> & {
+    body?: RequestData;
+    query?: RequestData;
+    params?: RequestData;
+    route?: Route<X, M>;
+  });
+  getBody(): RequestData;
+  header(name: string): string;
+  param(name: string): any;
+  input(name: string): any;
+  is(method: HttpMethod | string): boolean;
+}
+//#endregion
+export { Request };

package/dist/types/core/Response.d.mts

@@ -0,0 +1,21 @@
+//#region src/core/Response.d.ts
+declare class Response {
+  body: any;
+  headers: Headers;
+  sent: boolean;
+  statusCode: number;
+  constructor(init?: Partial<Response>);
+  status(code: number): this;
+  code(code: number): this;
+  setHeader(name: string, value: string): this;
+  header(name: string, value: string): this;
+  set(name: string, value: string): this;
+  type(contentType: string): this;
+  send(body?: any): this;
+  json(body: any): this;
+  html(body: string): this;
+  text(body: string): this;
+  noContent(): this;
+}
+//#endregion
+export { Response };

package/dist/types/express.d.mts

@@ -1,5 +1,6 @@
 import { ControllerHandler } from "./basic.mjs";
-import { ClearRequest } from "./ClearRequest.mjs";
+import { Response as Response$1 } from "./core/Response.mjs";
+import { Request as Request$1 } from "./core/Request.mjs";
 import { NextFunction, Request, Response } from "express";
 
 //#region types/express.d.ts
@@ -13,6 +14,8 @@ interface HttpContext {
   req: RequestWithGetBody;
   res: Response;
   next: NextFunction;
+  clearRequest: Request$1;
+  clearResponse: Response$1;
 }
 /**
  * Route handler function type
@@ -27,7 +30,7 @@ ctx: HttpContext,
  * ClearRequest instance
  */
 
-req: ClearRequest) => any | Promise<any>;
+req: Request$1) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */

package/dist/types/fastify.d.mts

@@ -1,5 +1,6 @@
 import { ControllerHandler } from "./basic.mjs";
-import { ClearRequest } from "./ClearRequest.mjs";
+import { Response } from "./core/Response.mjs";
+import { Request } from "./core/Request.mjs";
 import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
 
 //#region types/fastify.d.ts
@@ -9,8 +10,10 @@ interface RequestWithGetBody extends FastifyRequest {
 interface HttpContext {
   req: RequestWithGetBody;
   reply: FastifyReply;
+  clearRequest: Request;
+  clearResponse: Response;
 }
-type RouteHandler = (ctx: HttpContext, req: ClearRequest) => any | Promise<any>;
+type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
 type Handler = RouteHandler | ControllerHandler;
 type NextFunction = (err?: Error) => void;
 type Middleware = (req: RequestWithGetBody, reply: FastifyReply, next: NextFunction) => any | Promise<any>;

package/dist/types/h3.d.mts

@@ -1,5 +1,6 @@
 import { ControllerHandler } from "./basic.mjs";
-import { ClearRequest } from "./ClearRequest.mjs";
+import { Response as Response$1 } from "./core/Response.mjs";
+import { Request } from "./core/Request.mjs";
 import { EventHandlerRequest, H3, H3Event, Middleware, TypedServerRequest } from "h3";
 
 //#region types/h3.d.ts
@@ -16,6 +17,8 @@ type RequestlessH3Event = Omit<H3Event, 'req'>;
  */
 interface HttpContext extends RequestlessH3Event {
   req: HttpRequest;
+  clearRequest: Request;
+  clearResponse: Response$1;
 }
 /**
  * Route handler function type
@@ -30,7 +33,7 @@ ctx: HttpContext,
  * ClearRequest instance
  */
 
-req: ClearRequest) => any | Promise<any>;
+req: Request) => any | Promise<any>;
 /**
  * Handler can be either a function or controller reference
  */

package/dist/types/hono.d.mts

@@ -1,5 +1,6 @@
 import { ControllerHandler } from "./basic.mjs";
-import { ClearRequest } from "./ClearRequest.mjs";
+import { Response } from "./core/Response.mjs";
+import { Request } from "./core/Request.mjs";
 import { Context, HonoRequest, MiddlewareHandler } from "hono";
 
 //#region types/hono.d.ts
@@ -8,8 +9,10 @@ type RequestWithGetBody = HonoRequest & {
 };
 type HttpContext = Context & {
   req: RequestWithGetBody;
+  clearRequest: Request;
+  clearResponse: Response;
 };
-type RouteHandler = (ctx: HttpContext, req: ClearRequest) => any | Promise<any>;
+type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
 type Handler = RouteHandler | ControllerHandler;
 type NextFunction = () => Promise<void>;
 type Middleware = MiddlewareHandler;

package/dist/types/koa.d.mts

@@ -1,5 +1,6 @@
 import { ControllerHandler } from "./basic.mjs";
-import { ClearRequest } from "./ClearRequest.mjs";
+import { Response } from "./core/Response.mjs";
+import { Request } from "./core/Request.mjs";
 import Koa from "koa";
 import Router from "@koa/router";
 
@@ -10,10 +11,12 @@ interface RequestWithGetBody extends Koa.Request {
 }
 interface HttpContext extends Koa.Context {
   request: RequestWithGetBody;
+  clearRequest: Request;
+  clearResponse: Response;
   params: Record<string, any>;
   query: Record<string, any>;
 }
-type RouteHandler = (ctx: HttpContext, req: ClearRequest) => any | Promise<any>;
+type RouteHandler = (ctx: HttpContext, req: Request) => any | Promise<any>;
 type Handler = RouteHandler | ControllerHandler;
 type NextFunction = Koa.Next;
 type Middleware = Koa.Middleware<any, any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clear-router",
-  "version": "2.5.4",
+  "version": "2.5.6",
   "description": "Laravel-style routing for Node.js with support for Express, H3, Fastify, Hono, and Koa, including CommonJS, ESM, and TypeScript support.",
   "keywords": [
     "h3",
@@ -40,6 +40,14 @@
       "import": "./dist/core/index.mjs",
       "require": "./dist/core/index.cjs"
     },
+    "./decorators": {
+      "import": "./dist/decorators/index.mjs",
+      "require": "./dist/decorators/index.cjs"
+    },
+    "./decorators/setup": {
+      "import": "./dist/decorators/setup.mjs",
+      "require": "./dist/decorators/setup.cjs"
+    },
     "./express": {
       "import": "./dist/express/index.mjs",
       "require": "./dist/express/index.cjs"
@@ -79,7 +87,8 @@
     "fastify": "^5.0.0",
     "h3": "^2.0.1-rc.16",
     "hono": "^4.0.0",
-    "koa": "^3.0.0"
+    "koa": "^3.0.0",
+    "reflect-metadata": "^0.2.2"
   },
   "peerDependenciesMeta": {
     "@koa/router": {
@@ -99,6 +108,9 @@
     },
     "koa": {
       "optional": true
+    },
+    "reflect-metadata": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -115,10 +127,12 @@
     "hono": "^4.12.8",
     "koa": "^3.2.0",
     "parasito": "^0.1.6",
+    "reflect-metadata": "^0.2.2",
     "tsdown": "^0.20.3",
     "tsx": "^4.21.0",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.56.1",
+    "unrun": "0.2.27",
     "vite-tsconfig-paths": "^6.1.1",
     "vitepress": "^1.6.4",
     "vitest": "^4.0.18"