clear-router 2.5.4 → 2.5.6

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { NextFunction, Request, Response as Response$1 } from "express";
-import { Middleware } from "h3";
+import { NextFunction, Request as Request$1, Response as Response$2 } from "express";
+import { Middleware as Middleware$1 } from "h3";
 
 //#region types/basic.d.ts
 /**
@@ -26,16 +26,37 @@ 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
-/**
- * Middleware function type
- */
-type Middleware$1 = (req: Request, res: Response$1, next: NextFunction) => any | Promise<any>;
+//#region src/core/Response.d.ts
+declare class Response$1 {
+  body: any;
+  headers: Headers;
+  sent: boolean;
+  statusCode: number;
+  constructor(init?: Partial<Response$1>);
+  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 src/Route.d.ts
-declare class Route<X = any, M = Middleware | Middleware$1, H = any> {
+declare class Route<X = any, M = Middleware$1 | Middleware, H = any> {
   ctx: X;
   body: RequestData;
   query: RequestData;
@@ -52,8 +73,34 @@ declare class Route<X = any, M = Middleware | Middleware$1, H = any> {
   constructor(methods: HttpMethod[], path: string, handler: H, middlewares?: M[]);
 }
 //#endregion
+//#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
+//#region types/express.d.ts
+/**
+ * Middleware function type
+ */
+type Middleware = (req: Request$1, res: Response$2, next: NextFunction) => any | Promise<any>;
+//#endregion
 //#region src/ClearRequest.d.ts
-declare class ClearRequest<X = any, M = Middleware | Middleware$1> {
+declare class ClearRequest<X = any, M = Middleware$1 | Middleware> {
   [key: string]: any;
   /**
    * @param body - Parsed request body
@@ -81,6 +128,37 @@ declare abstract class Controller<X = any> {
   clearRequest: ClearRequest;
 }
 //#endregion
+//#region src/core/bindings.d.ts
+type BindToken<T = any> = abstract new (...args: any[]) => T;
+type BindFactory<T = any> = (ctx: any) => T | Promise<T>;
+type BindValue<T = any> = T | BindFactory<T> | BindToken<T>;
+declare class Container {
+  private static readonly registry;
+  static bind<T>(token: BindToken<T>, value: BindValue<T>): void;
+  static unbind<T>(token: BindToken<T>): void;
+  static clear(): void;
+  static has<T>(token: BindToken<T>): boolean;
+  static resolve<T>(token: BindToken<T>, ctx: any, autoDiscover?: boolean): Promise<T | undefined>;
+  private static resolveBinding;
+}
+//#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/core/router.d.ts
 /**
  * @class clear-router CoreRouter
@@ -92,16 +170,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[];
@@ -116,6 +194,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[];
@@ -265,14 +353,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) => 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) => 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 { ClearRequest, Controller, CoreRouter, Route };
+export { ClearRequest, ClearRouterPlugin, ClearRouterPluginContext, ClearRouterPluginInput, Controller, CoreRouter, PluginBind, PluginSetupResult, Request, Response$1 as Response, Route, definePlugin };

package/dist/index.mjs

@@ -58,6 +58,152 @@ var Route = class {
 	}
 };
 
+//#endregion
+//#region src/core/Request.ts
+var Request = class extends ClearRequest {
+	original;
+	method = "GET";
+	path = "/";
+	url = "/";
+	headers = {};
+	constructor(init) {
+		super(init);
+		Object.assign(this, init);
+	}
+	getBody() {
+		return this.body ?? {};
+	}
+	header(name) {
+		if (typeof this.headers.get === "function") return this.headers.get(name) || "";
+		const headers = this.headers;
+		const value = headers[name] ?? headers[name.toLowerCase()];
+		return Array.isArray(value) ? String(value[0] ?? "") : String(value ?? "");
+	}
+	param(name) {
+		return this.params?.[name];
+	}
+	input(name) {
+		return this.body?.[name] ?? this.query?.[name] ?? this.params?.[name];
+	}
+	is(method) {
+		return this.method.toLowerCase() === String(method).toLowerCase();
+	}
+};
+
+//#endregion
+//#region src/core/Response.ts
+var Response = class {
+	body;
+	headers = new Headers();
+	sent = false;
+	statusCode = 200;
+	constructor(init) {
+		Object.assign(this, init);
+		if (init?.headers && !(init.headers instanceof Headers)) this.headers = new Headers(init.headers);
+	}
+	status(code) {
+		this.statusCode = code;
+		return this;
+	}
+	code(code) {
+		return this.status(code);
+	}
+	setHeader(name, value) {
+		this.headers.set(name, value);
+		return this;
+	}
+	header(name, value) {
+		return this.setHeader(name, value);
+	}
+	set(name, value) {
+		return this.setHeader(name, value);
+	}
+	type(contentType) {
+		return this.setHeader("Content-Type", contentType);
+	}
+	send(body) {
+		this.body = body;
+		this.sent = true;
+		return this;
+	}
+	json(body) {
+		return this.type("application/json; charset=utf-8").send(body);
+	}
+	html(body) {
+		return this.type("text/html; charset=utf-8").send(body);
+	}
+	text(body) {
+		return this.type("text/plain; charset=utf-8").send(body);
+	}
+	noContent() {
+		return this.status(204).send(null);
+	}
+};
+
+//#endregion
+//#region src/core/plugins.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+
+//#endregion
+//#region src/core/bindings.ts
+const metadataKey = Symbol.for("clear-router:binding-metadata");
+const bindings = /* @__PURE__ */ new WeakMap();
+var Container = class {
+	static registry = /* @__PURE__ */ new Map();
+	static bind(token, value) {
+		this.registry.set(token, value);
+	}
+	static unbind(token) {
+		this.registry.delete(token);
+	}
+	static clear() {
+		this.registry.clear();
+	}
+	static has(token) {
+		return this.registry.has(token);
+	}
+	static async resolve(token, ctx, autoDiscover = false) {
+		if (token === Request) return ctx.clearRequest;
+		if (token === Response) return ctx.clearResponse;
+		if (this.registry.has(token)) return this.resolveBinding(this.registry.get(token), ctx, autoDiscover);
+		if (autoDiscover && typeof token === "function") return new token();
+	}
+	static async resolveBinding(binding, ctx, autoDiscover) {
+		if (!binding) return void 0;
+		if (typeof binding !== "function") return binding;
+		if (isClass(binding)) return new binding();
+		const resolved = await binding(ctx);
+		if (typeof resolved === "function" && autoDiscover && isClass(resolved)) return new resolved();
+		return resolved;
+	}
+};
+function getStandardMetadata(metadata, propertyKey) {
+	const store = metadata && metadata[metadataKey];
+	if (!store) return void 0;
+	return propertyKey ? store[propertyKey] : void 0;
+}
+function getBindingMetadataFromTargets(targets) {
+	for (const { target, propertyKey } of targets) {
+		if (!target) continue;
+		const metadata = getBindingMetadata(target, propertyKey);
+		if (metadata) return metadata;
+		const standardMetadata = getStandardMetadata(target[Symbol.metadata], propertyKey);
+		if (standardMetadata) return standardMetadata;
+	}
+}
+function getBindingMetadata(target, propertyKey) {
+	if (propertyKey) return bindings.get(target)?.get(propertyKey);
+	return bindings.get(target)?.get("__route_handler__");
+}
+function getDesignParamTypes(target, propertyKey) {
+	return Reflect.getMetadata?.("design:paramtypes", target, propertyKey) ?? [];
+}
+function isClass(value) {
+	return typeof value === "function" && /^class\s/.test(Function.prototype.toString.call(value));
+}
+
 //#endregion
 //#region src/core/router.ts
 /**
@@ -70,6 +216,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");
 	}
@@ -78,13 +259,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 AsyncLocalStorage(),
 			routes: [],
 			routesByPathMethod: {},
@@ -161,11 +343,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: Container,
+			bind: Container.bind.bind(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 AsyncLocalStorage();
 	static routes = [];
 	static routesByPathMethod = {};
@@ -207,11 +425,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;
@@ -448,38 +667,96 @@ 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 = getBindingMetadataFromTargets([
+			{
+				target: bindingTarget,
+				propertyKey: bindingMethod
+			},
+			{ target: bindingHandler },
+			{
+				target: bindingTarget,
+				propertyKey: "__class__"
+			}
+		]) ?? getStandardMetadata(bindingMetadata, bindingMethod) ?? getStandardMetadata(bindingMetadata, "__class__");
+		if (!metadata) return handlerFunction(ctx, ctx.clearRequest);
+		const designTokens = [...bindingTarget ? getDesignParamTypes(bindingTarget, bindingMethod) : [], ...bindingHandler ? 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 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 Request ? ctx.clearRequest : new 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 Response)) ctx.clearResponse = new 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;
 	}
 };
 
 //#endregion
-export { ClearRequest, Controller, CoreRouter, Route };
+export { ClearRequest, Controller, CoreRouter, Request, Response, Route, definePlugin };

package/dist/koa/index.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_router = require('../router-CHg0pZUO.cjs');
-const require_responses = require('../responses-B-UirWFf.cjs');
+require('../bindings-DvV2DXWi.cjs');
+const require_router = require('../router-CU4V1kX0.cjs');
+const require_responses = require('../responses-JzXstGU5.cjs');
 
 //#region src/koa/router.ts
 /**
@@ -44,6 +45,9 @@ var Router = class Router extends require_router.CoreRouter {
 		});
 		if (!meta) return void 0;
 		ctx.status = meta.status;
+		meta.headers?.forEach((headerValue, key) => {
+			ctx.set(key, headerValue);
+		});
 		if (require_responses.isFetchResponse(meta.body)) {
 			meta.body.headers.forEach((headerValue, key) => {
 				ctx.set(key, headerValue);
@@ -180,10 +184,18 @@ var Router = class Router extends require_router.CoreRouter {
 		for (const route of this.routes) {
 			let handlerFunction = null;
 			let instance = null;
+			let bindingTarget;
+			let bindingMethod;
+			let bindingHandler;
+			let bindingMetadata;
 			try {
 				const resolved = this.resolveHandler(route);
 				handlerFunction = resolved.handlerFunction;
 				instance = resolved.instance;
+				bindingTarget = resolved.bindingTarget;
+				bindingMethod = resolved.bindingMethod;
+				bindingHandler = resolved.bindingHandler;
+				bindingMetadata = resolved.bindingMetadata;
 			} catch (error) {
 				console.error(`[ROUTES] Error setting up route ${route.path}:`, error.message);
 				throw error;
@@ -210,11 +222,13 @@ var Router = class Router extends require_router.CoreRouter {
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {}
+						params: ctx.params ?? {},
+						method
 					});
-					const result = handlerFunction(ctx, inst.clearRequest);
+					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
 					const resolved = await Promise.resolve(result);
-					return Router.sendReturnValue(ctx, resolved, method, route.path);
+					const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+					return Router.sendReturnValue(ctx, outgoing, method, route.path);
 				});
 				if ([
 					"put",
@@ -228,11 +242,13 @@ var Router = class Router extends require_router.CoreRouter {
 					Router.bindRequestToInstance(ctx, inst, route, {
 						body: reqBody,
 						query: ctx.query,
-						params: ctx.params ?? {}
+						params: ctx.params ?? {},
+						method
 					});
-					const result = handlerFunction(ctx, inst.clearRequest);
+					const result = await Router.callHandler(handlerFunction, ctx, bindingTarget, bindingMethod, bindingHandler, bindingMetadata);
 					const resolved = await Promise.resolve(result);
-					return Router.sendReturnValue(ctx, resolved, method, route.path);
+					const outgoing = typeof resolved === "undefined" && ctx.clearResponse?.sent ? ctx.clearResponse : resolved;
+					return Router.sendReturnValue(ctx, outgoing, method, route.path);
 				});
 			}
 		}

package/dist/koa/index.d.cts

@@ -1,4 +1,4 @@
-import { d as ApiResourceMiddleware, f as ControllerAction, m as HttpMethod, n as ClearRequest, p as ControllerHandler, r as Route, t as CoreRouter } from "../router-CS_2XQ7I.cjs";
+import { _ as ApiResourceMiddleware, b as HttpMethod, c as Request, l as Route, t as CoreRouter, v as ControllerAction, x as Response, y as ControllerHandler } from "../router-BYZmNzrZ.cjs";
 import Koa from "koa";
 import Router$1 from "@koa/router";
 
@@ -9,10 +9,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 Middleware = Koa.Middleware<any, any>;
 type KoaRouterApp = Router$1<any, any>;