@keq-request/nestjs 5.0.0-beta.13 → 5.0.0-beta.15

package/dist/index.mjs

@@ -1,20 +1,34 @@
-import { Global, Module } from "@nestjs/common";
-import { ModulesContainer } from "@nestjs/core";
+import { Global, Inject, Injectable, Module } from "@nestjs/common";
 import { KeqRequest, composeRoute } from "keq";
 import picomatch from "picomatch";
 //#region src/constants.ts
 const KEQ_ROUTES = { ALL: Symbol("KEQ_ROUTES.ALL") };
 //#endregion
-//#region src/keq-middleware-consumer.ts
-var KeqMiddlewareConsumerImpl = class {
+//#region src/keq-middleware-collector.ts
+/**
+* 中间件收集器，收集中间件配置条目并应用到指定的 {@link KeqRequest} 实例。
+*
+* 通过 `apply()` → `forRoutes()` 链式 API 收集多组中间件条目，
+* 在 `forRoutes()` 被调用时立即将中间件绑定到目标请求。
+*
+* 注意：该类并非 `@Injectable()`，由 Consumer 内部手动创建。
+*
+* @typeParam TConsumer - Consumer 类型（`KeqMiddlewareConsumer` 或 `KeqConsumer<T>`）
+*/
+var KeqMiddlewareCollector = class {
 	entries = [];
-	apply(...middlewares) {
+	constructor(keqRequest, consumer) {
+		this.keqRequest = keqRequest;
+		this.consumer = consumer;
+	}
+	apply(middlewares) {
 		const entry = {
 			middlewares,
 			routes: []
 		};
 		const excludedRouteInfos = [];
 		this.entries.push(entry);
+		const { keqRequest, consumer } = this;
 		const proxy = {
 			exclude: (...routes) => {
 				excludedRouteInfos.push(...routes);
@@ -23,14 +37,18 @@ var KeqMiddlewareConsumerImpl = class {
 			forRoutes: (...routes) => {
 				entry.routes = routes;
 				if (excludedRouteInfos.length > 0) entry.excludedRouteInfos = excludedRouteInfos;
-				return this;
+				this.applyTo(keqRequest);
+				return consumer;
 			}
 		};
 		return proxy;
 	}
-	applyTo(keqRequest, modulesContainer) {
+	/**
+	* 将收集的所有中间件条目解析并应用到指定的 {@link KeqRequest} 实例。
+	*/
+	applyTo(keqRequest) {
 		for (const entry of this.entries) {
-			let resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, modulesContainer));
+			let resolved = entry.middlewares.map((m) => this.normalizeMiddleware(m));
 			if (entry.excludedRouteInfos && entry.excludedRouteInfos.length > 0) {
 				const excludedRoutes = entry.excludedRouteInfos.map((info) => this.buildRoute(info));
 				resolved = resolved.map((mw) => this.wrapWithExclusion(mw, excludedRoutes));
@@ -38,56 +56,24 @@ var KeqMiddlewareConsumerImpl = class {
 			if (entry.routes.length === 0 || entry.routes.some((r) => r === KEQ_ROUTES.ALL)) for (const mw of resolved) keqRequest.use(mw);
 			else for (const routeTarget of entry.routes) {
 				if (routeTarget === KEQ_ROUTES.ALL) continue;
-				if (this.isKeqModuleClass(routeTarget)) {
-					const targetRequest = this.findInModulesContainer(routeTarget, modulesContainer);
-					if (targetRequest) for (const mw of resolved) targetRequest.use(mw);
-				} else {
-					const route = this.buildRoute(routeTarget);
-					keqRequest.useRouter().route(route, resolved);
-				}
+				const route = this.buildRoute(routeTarget);
+				keqRequest.useRouter().route(route, resolved);
 			}
 		}
 	}
-	isKeqModuleClass(route) {
-		return typeof route === "function" && "KEQ_REQUEST" in route && typeof route.KEQ_REQUEST === "symbol";
-	}
-	isNestMiddlewareClass(m) {
-		return typeof m === "function" && m.prototype !== void 0 && "use" in m.prototype;
-	}
-	findMiddlewareInstance(middlewareClass, modulesContainer) {
-		for (const [, moduleWrapper] of modulesContainer) {
-			const provider = moduleWrapper.providers.get(middlewareClass);
-			if (provider?.instance) return provider.instance;
-		}
-	}
-	resolveMiddleware(m, modulesContainer) {
-		if (this.isNestMiddlewareClass(m)) {
-			const instance = this.findMiddlewareInstance(m, modulesContainer);
-			if (!instance) throw new Error(`[KeqModule] Nest middleware class '${m.name}' is not registered as a provider in any module. Ensure the middleware class is added to the providers array of a @Module() decorator.`);
-			return async (ctx, next) => {
-				await instance.use(ctx, next);
-			};
-		}
-		return m;
-	}
 	/**
-	* 从 ModulesContainer 中查找目标 KeqModule 的 KeqRequest 实例
-	*
-	* 通过 metatype 精确匹配模块，从模块 providers 中直接获取 KeqRequest。
-	* 不依赖 ModuleRef 的作用域机制，直接从 NestJS 全局模块容器中查找。
-	*
-	* @param routeTarget - 目标 KeqModule 类，必须具有 KEQ_REQUEST symbol 属性
-	* @param modulesContainer - NestJS 全局模块容器
-	* @returns KeqRequest 实例，未找到时返回 undefined
+	* 标准化中间件：将不同形式的中间件统一为 {@link KeqMiddleware} 函数。
+	* - 若已是 {@link KeqMiddleware} 函数 → 直接返回
+	* - 若为 {@link KeqNestMiddleware} 实例对象 → 包装 `use` 方法为中间件函数
 	*/
-	findInModulesContainer(routeTarget, modulesContainer) {
-		const token = routeTarget.KEQ_REQUEST;
-		for (const [, moduleWrapper] of modulesContainer) {
-			if (moduleWrapper.metatype !== routeTarget) continue;
-			const provider = moduleWrapper.providers.get(token);
-			if (!provider) continue;
-			if (provider.instance) return provider.instance;
-		}
+	normalizeMiddleware(m) {
+		if (this.isNestMiddlewareInstance(m)) return async (ctx, next) => {
+			await m.use(ctx, next);
+		};
+		return m;
+	}
+	isNestMiddlewareInstance(m) {
+		return typeof m === "object" && m !== null && "use" in m;
 	}
 	buildRoute(info) {
 		const routes = [];
@@ -119,11 +105,6 @@ var KeqMiddlewareConsumerImpl = class {
 	}
 };
 //#endregion
-//#region src/utils/has-configure-keq-middleware.ts
-function hasConfigureKeqMiddleware(instance) {
-	return instance !== null && instance !== void 0 && typeof instance.configureKeqMiddleware === "function";
-}
-//#endregion
 //#region \0@oxc-project+runtime@0.127.0/helpers/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
@@ -137,79 +118,77 @@ function __decorate(decorators, target, key, desc) {
 	return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 //#endregion
+//#region src/keq-middleware-consumer.ts
+var _ref;
+let KeqMiddlewareConsumer = class KeqMiddlewareConsumer {
+	constructor(keqRequest) {
+		this.keqRequest = keqRequest;
+	}
+	apply(...middlewares) {
+		return new KeqMiddlewareCollector(this.keqRequest, this).apply(middlewares);
+	}
+};
+KeqMiddlewareConsumer = __decorate([Injectable(), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof KeqRequest !== "undefined" && KeqRequest) === "function" ? _ref : Object])], KeqMiddlewareConsumer);
+//#endregion
 //#region src/keq.module.ts
-var _ref, _ref2;
+let KeqModule = class KeqModule {};
+KeqModule = __decorate([Global(), Module({
+	providers: [{
+		provide: KeqRequest,
+		useFactory: () => new KeqRequest()
+	}, KeqMiddlewareConsumer],
+	exports: [KeqRequest, KeqMiddlewareConsumer]
+})], KeqModule);
+//#endregion
+//#region src/keq-consumer.ts
 /**
-* 全局标记，用于跨 KeqModule 实例去重
+* 为指定 Keq 模块按路由注册中间件。
 *
-* 当 pnpm 等包管理器因为 peerDependencies 版本差异生成多个
-* `@keq-request/nestjs` 的 `.pnpm` 目录时，Node.js 会将它们视为不同模块，
-* 产生多个 `KeqModule` 类引用，导致 NestJS 创建多个 `KeqModule` 实例。
+* Keq 模块由 `@keq-request/cli` 生成，通过
+* {@link InjectKeqConsumer} 装饰器注入本实例。
 *
-* 每个实例的 `onModuleInit()` 都会遍历 `ModulesContainer` 并调用所有
-* 实现了 `configureKeqMiddleware` 的模块。通过 `Symbol.for()`（全局 Symbol
-* 注册表）在 `moduleWrapper.metatype` 上做标记，确保同一个模块类
-* 只被处理一次，无论有多少个 `KeqModule` 实例。
+* @typeParam T - 目标模块类
+*
+* @example
+* ```ts
+* constructor(
+*   \@InjectKeqConsumer(GeneratedModule) consumer: KeqConsumer<GeneratedModule>,
+* ) {
+*   consumer.apply(authMw).forRoutes('*')
+* }
+* ```
 */
-const CONFIGURED_SYMBOL = Symbol.for("__keq_middleware_configured__");
+var KeqConsumer = class {
+	constructor(keqRequest) {
+		this.keqRequest = keqRequest;
+	}
+	apply(...middlewares) {
+		return new KeqMiddlewareCollector(this.keqRequest, this).apply(middlewares);
+	}
+};
+//#endregion
+//#region src/decorators/inject-keq-consumer.decorator.ts
 /**
-* 在 NestJS 模块初始化早期阶段校验 `configureKeqMiddleware` 的实现模块
-* 是否显式导入了 `KeqModule`。
+* 注入绑定到指定 Keq Module 的 `KeqConsumer<T>`。
 *
-* NestJS 初始化分为两个严格串行的阶段：
-* 1. 全量扫描 — 所有模块 wrapper 加入 ModulesContainer，metatype 已设置，
-*    DynamicModule 的 imports 已被解析并写入 moduleWrapper.imports Set
-* 2. 实例创建 — 按依赖顺序调用构造函数 → onModuleInit
+* 被注入的 Module Class 必须同时包含 `KEQ_REQUEST` 和 `KEQ_CONSUMER` 静态属性，
+* 两者均由 keq CLI 生成。
 *
-* 此校验在阶段 2 开头（构造函数中）执行，早于所有 onModuleInit，
-* 确保中间件缺失问题在启动期就被捕获，而非在业务模块 onModuleInit 发请求时静默失效。
+* 使用方式：
+* ```ts
+* constructor(
+*   \@InjectKeqConsumer(GeneratedModule) consumer: KeqConsumer<GeneratedModule>,
+* ) {
+*   consumer.apply(mw).forRoutes('*')
+* }
+* ```
 *
-* 使用运行时 imports Set 而非 Reflect.getMetadata('imports', metatype) 的原因：
-* - DynamicModule 通过 register() 返回的 imports 不在静态装饰器元数据中
-* - 从 ModulesContainer 获取 KeqModule metatype 可避免 pnpm 重复包实例导致的 === 比对失败
+* @param moduleClass - 目标 KeqModule 类（需具有 `KEQ_REQUEST` 和 `KEQ_CONSUMER` symbol）
 */
-function validateConfigureKeqMiddlewareImports(modulesContainer) {
-	let keqModuleMetatype;
-	for (const [, moduleWrapper] of modulesContainer) if (moduleWrapper.metatype?.name === "KeqModule") {
-		keqModuleMetatype = moduleWrapper.metatype;
-		break;
-	}
-	for (const [, moduleWrapper] of modulesContainer) {
-		const metatype = moduleWrapper.metatype;
-		if (typeof metatype?.prototype?.configureKeqMiddleware !== "function") continue;
-		if (![...moduleWrapper.imports].some((importedModule) => importedModule.metatype === keqModuleMetatype)) throw new Error(`[KeqModule] '${metatype.name}' implements configureKeqMiddleware() but does not explicitly import KeqModule. Add 'imports: [KeqModule]' to its @Module() decorator to ensure middleware is registered before the module's onModuleInit() runs.`);
-	}
+function InjectKeqConsumer(moduleClass) {
+	return Inject(moduleClass.KEQ_CONSUMER);
 }
-let KeqModule = class KeqModule {
-	constructor(modulesContainer, keqRequest) {
-		this.modulesContainer = modulesContainer;
-		this.keqRequest = keqRequest;
-		validateConfigureKeqMiddlewareImports(modulesContainer);
-	}
-	onModuleInit() {
-		for (const [, moduleWrapper] of this.modulesContainer) {
-			const instance = moduleWrapper.instance;
-			if (!hasConfigureKeqMiddleware(instance)) continue;
-			if (moduleWrapper.metatype[CONFIGURED_SYMBOL]) continue;
-			moduleWrapper.metatype[CONFIGURED_SYMBOL] = true;
-			const consumer = new KeqMiddlewareConsumerImpl();
-			instance.configureKeqMiddleware(consumer);
-			consumer.applyTo(this.keqRequest, this.modulesContainer);
-		}
-	}
-};
-KeqModule = __decorate([
-	Global(),
-	Module({
-		providers: [{
-			provide: KeqRequest,
-			useFactory: () => new KeqRequest()
-		}],
-		exports: [KeqRequest]
-	}),
-	__decorateMetadata("design:paramtypes", [typeof (_ref = typeof ModulesContainer !== "undefined" && ModulesContainer) === "function" ? _ref : Object, typeof (_ref2 = typeof KeqRequest !== "undefined" && KeqRequest) === "function" ? _ref2 : Object])
-], KeqModule);
 //#endregion
-export { KEQ_ROUTES, KeqModule, validateConfigureKeqMiddlewareImports };
+export { InjectKeqConsumer, KEQ_ROUTES, KeqConsumer, KeqMiddlewareConsumer, KeqModule };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/constants.ts","../src/keq-middleware-consumer.ts","../src/utils/has-configure-keq-middleware.ts","../src/keq.module.ts"],"sourcesContent":["export const KEQ_ROUTES = {\n  ALL: Symbol('KEQ_ROUTES.ALL'),\n} as const\n","import type { Type } from '@nestjs/common'\nimport type { ModulesContainer } from '@nestjs/core'\nimport type { KeqExecutionContext, KeqMiddleware, KeqRoute } from 'keq'\nimport { composeRoute, KeqRequest } from 'keq'\nimport picomatch from 'picomatch'\nimport { KEQ_ROUTES } from './constants.js'\nimport type { KeqMiddlewareConfigProxy, KeqMiddlewareConsumer, KeqModuleClass, KeqRouteInfo } from './interfaces/keq-middleware-consumer.interface.js'\nimport type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'\n\n\ninterface MiddlewareEntry {\n  middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>\n  routes: Array<typeof KEQ_ROUTES.ALL | KeqRouteInfo | KeqModuleClass>\n  excludedRouteInfos?: KeqRouteInfo[]\n}\n\nexport class KeqMiddlewareConsumerImpl implements KeqMiddlewareConsumer {\n  private entries: MiddlewareEntry[] = []\n\n  apply(...middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>): KeqMiddlewareConfigProxy {\n    const entry: MiddlewareEntry = { middlewares, routes: [] }\n    const excludedRouteInfos: KeqRouteInfo[] = []\n    this.entries.push(entry)\n\n    const proxy: KeqMiddlewareConfigProxy = {\n      exclude: (...routes) => {\n        excludedRouteInfos.push(...routes)\n        return proxy\n      },\n      forRoutes: (...routes) => {\n        entry.routes = routes\n        if (excludedRouteInfos.length > 0) {\n          entry.excludedRouteInfos = excludedRouteInfos\n        }\n        return this\n      },\n    }\n    return proxy\n  }\n\n  applyTo(keqRequest: KeqRequest, modulesContainer: ModulesContainer): void {\n    for (const entry of this.entries) {\n      let resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, modulesContainer))\n\n      if (entry.excludedRouteInfos && entry.excludedRouteInfos.length > 0) {\n        const excludedRoutes = entry.excludedRouteInfos.map((info) => this.buildRoute(info))\n        resolved = resolved.map((mw) => this.wrapWithExclusion(mw, excludedRoutes))\n      }\n\n      const isGlobal = entry.routes.length === 0\n        || entry.routes.some((r) => r === KEQ_ROUTES.ALL)\n\n      if (isGlobal) {\n        for (const mw of resolved) keqRequest.use(mw)\n      } else {\n        for (const routeTarget of entry.routes) {\n          if (routeTarget === KEQ_ROUTES.ALL) continue\n\n          if (this.isKeqModuleClass(routeTarget)) {\n            const targetRequest = this.findInModulesContainer(routeTarget, modulesContainer)\n            if (targetRequest) {\n              for (const mw of resolved) targetRequest.use(mw)\n            }\n          } else {\n            const route = this.buildRoute(routeTarget as KeqRouteInfo)\n            keqRequest.useRouter().route(route, resolved)\n          }\n        }\n      }\n    }\n  }\n\n  private isKeqModuleClass(route: unknown): route is KeqModuleClass {\n    return (\n      typeof route === 'function'\n      && 'KEQ_REQUEST' in route\n      && typeof (route as Record<string, unknown>).KEQ_REQUEST === 'symbol'\n    )\n  }\n\n  private isNestMiddlewareClass(m: Type<KeqNestMiddleware> | KeqMiddleware): m is Type<KeqNestMiddleware> {\n    return typeof m === 'function' && m.prototype !== undefined && 'use' in m.prototype\n  }\n\n  private findMiddlewareInstance(\n    middlewareClass: Type<KeqNestMiddleware>,\n    modulesContainer: ModulesContainer,\n  ): KeqNestMiddleware | undefined {\n    for (const [, moduleWrapper] of modulesContainer) {\n      const provider = moduleWrapper.providers.get(middlewareClass)\n      if (provider?.instance) {\n        return provider.instance as KeqNestMiddleware\n      }\n    }\n    return undefined\n  }\n\n  private resolveMiddleware(\n    m: Type<KeqNestMiddleware> | KeqMiddleware,\n    modulesContainer: ModulesContainer,\n  ): KeqMiddleware {\n    if (this.isNestMiddlewareClass(m)) {\n      const instance = this.findMiddlewareInstance(m, modulesContainer)\n      if (!instance) {\n        throw new Error(\n          `[KeqModule] Nest middleware class '${m.name}' is not registered as a provider in any module. `\n          + 'Ensure the middleware class is added to the providers array of a @Module() decorator.',\n        )\n      }\n      return async (ctx, next) => {\n        await instance.use(ctx, next)\n      }\n    }\n    return m\n  }\n\n  /**\n   * 从 ModulesContainer 中查找目标 KeqModule 的 KeqRequest 实例\n   *\n   * 通过 metatype 精确匹配模块，从模块 providers 中直接获取 KeqRequest。\n   * 不依赖 ModuleRef 的作用域机制，直接从 NestJS 全局模块容器中查找。\n   *\n   * @param routeTarget - 目标 KeqModule 类，必须具有 KEQ_REQUEST symbol 属性\n   * @param modulesContainer - NestJS 全局模块容器\n   * @returns KeqRequest 实例，未找到时返回 undefined\n   */\n  private findInModulesContainer(\n    routeTarget: KeqModuleClass,\n    modulesContainer: ModulesContainer,\n  ): KeqRequest | undefined {\n    const token = routeTarget.KEQ_REQUEST\n    for (const [, moduleWrapper] of modulesContainer) {\n      if (moduleWrapper.metatype !== routeTarget) continue\n\n      const provider = moduleWrapper.providers.get(token)\n      if (!provider) continue\n\n      if (provider.instance) {\n        return provider.instance as KeqRequest\n      }\n    }\n    return undefined\n  }\n\n  private buildRoute(info: KeqRouteInfo): KeqRoute {\n    const routes: KeqRoute[] = []\n    if (info.host) {\n      const host = info.host\n      routes.push((ctx) => ctx.request.url.host === host)\n    }\n    if (info.method) {\n      const method = info.method.toLowerCase()\n      routes.push((ctx) => ctx.request.method.toLowerCase() === method)\n    }\n    if (info.pathname) {\n      const isMatch: (test: string) => boolean = picomatch(info.pathname)\n      routes.push((ctx) => isMatch(ctx.request.url.pathname))\n    }\n    if (routes.length === 1) return routes[0]\n    return composeRoute(routes)\n  }\n\n  private wrapWithExclusion(middleware: KeqMiddleware, excludedRoutes: KeqRoute[]): KeqMiddleware {\n    const excluded: KeqMiddleware = async (ctx, next) => {\n      if (await this.checkExcluded(ctx, excludedRoutes)) {\n        return next()\n      }\n      return middleware(ctx, next)\n    }\n    return excluded\n  }\n\n  private async checkExcluded(ctx: KeqExecutionContext, excludedRoutes: KeqRoute[]): Promise<boolean> {\n    for (const route of excludedRoutes) {\n      if (await route(ctx)) return true\n    }\n    return false\n  }\n}\n","import type { KeqMiddlewareModule } from '../interfaces/keq-middleware-module.interface.js'\n\n\nexport function hasConfigureKeqMiddleware(instance: unknown): instance is KeqMiddlewareModule {\n  return (\n    instance !== null\n    && instance !== undefined\n    && typeof (instance as Record<string, unknown>).configureKeqMiddleware === 'function'\n  )\n}\n","import { Global, Module, OnModuleInit, Type } from '@nestjs/common'\nimport { ModulesContainer } from '@nestjs/core'\nimport { KeqRequest } from 'keq'\nimport { KeqMiddlewareConsumerImpl } from './keq-middleware-consumer.js'\nimport { hasConfigureKeqMiddleware } from './utils/has-configure-keq-middleware.js'\n\n/**\n * 全局标记，用于跨 KeqModule 实例去重\n *\n * 当 pnpm 等包管理器因为 peerDependencies 版本差异生成多个\n * `@keq-request/nestjs` 的 `.pnpm` 目录时，Node.js 会将它们视为不同模块，\n * 产生多个 `KeqModule` 类引用，导致 NestJS 创建多个 `KeqModule` 实例。\n *\n * 每个实例的 `onModuleInit()` 都会遍历 `ModulesContainer` 并调用所有\n * 实现了 `configureKeqMiddleware` 的模块。通过 `Symbol.for()`（全局 Symbol\n * 注册表）在 `moduleWrapper.metatype` 上做标记，确保同一个模块类\n * 只被处理一次，无论有多少个 `KeqModule` 实例。\n */\nconst CONFIGURED_SYMBOL = Symbol.for('__keq_middleware_configured__')\n\n/**\n * 在 NestJS 模块初始化早期阶段校验 `configureKeqMiddleware` 的实现模块\n * 是否显式导入了 `KeqModule`。\n *\n * NestJS 初始化分为两个严格串行的阶段：\n * 1. 全量扫描 — 所有模块 wrapper 加入 ModulesContainer，metatype 已设置，\n *    DynamicModule 的 imports 已被解析并写入 moduleWrapper.imports Set\n * 2. 实例创建 — 按依赖顺序调用构造函数 → onModuleInit\n *\n * 此校验在阶段 2 开头（构造函数中）执行，早于所有 onModuleInit，\n * 确保中间件缺失问题在启动期就被捕获，而非在业务模块 onModuleInit 发请求时静默失效。\n *\n * 使用运行时 imports Set 而非 Reflect.getMetadata('imports', metatype) 的原因：\n * - DynamicModule 通过 register() 返回的 imports 不在静态装饰器元数据中\n * - 从 ModulesContainer 获取 KeqModule metatype 可避免 pnpm 重复包实例导致的 === 比对失败\n */\nexport function validateConfigureKeqMiddlewareImports(modulesContainer: ModulesContainer): void {\n  // 从 ModulesContainer 中查找 KeqModule 的 metatype，\n  // 解决 pnpm 下 @keq-request/nestjs 存在多个包实例导致 === 引用比对失败的问题\n  let keqModuleMetatype: Type<any> | undefined\n  for (const [, moduleWrapper] of modulesContainer) {\n    if (moduleWrapper.metatype?.name === 'KeqModule') {\n      keqModuleMetatype = moduleWrapper.metatype\n      break\n    }\n  }\n\n  for (const [, moduleWrapper] of modulesContainer) {\n    const metatype = moduleWrapper.metatype\n    if (typeof metatype?.prototype?.configureKeqMiddleware !== 'function') continue\n\n    // 使用运行时 imports Set（NestJS 扫描阶段已解析 DynamicModule 的 imports），\n    // 替代 Reflect.getMetadata('imports', metatype)，解决：\n    // 1. DynamicModule 的 imports 无法通过静态元数据检测\n    // 2. 重复包实例导致的类引用不匹配\n    const hasKeqModule = [...moduleWrapper.imports].some(\n      (importedModule) => importedModule.metatype === keqModuleMetatype,\n    )\n\n    if (!hasKeqModule) {\n      throw new Error(\n        `[KeqModule] '${metatype.name}' implements configureKeqMiddleware() `\n        + 'but does not explicitly import KeqModule. '\n        + 'Add \\'imports: [KeqModule]\\' to its @Module() decorator to ensure '\n        + 'middleware is registered before the module\\'s onModuleInit() runs.',\n      )\n    }\n  }\n}\n\n@Global()\n@Module({\n  providers: [{ provide: KeqRequest, useFactory: () => new KeqRequest() }],\n  exports: [KeqRequest],\n})\nexport class KeqModule implements OnModuleInit {\n  constructor(\n    private readonly modulesContainer: ModulesContainer,\n    private readonly keqRequest: KeqRequest,\n  ) {\n    validateConfigureKeqMiddlewareImports(modulesContainer)\n  }\n\n  onModuleInit(): void {\n    for (const [, moduleWrapper] of this.modulesContainer) {\n      const instance = moduleWrapper.instance\n      if (!hasConfigureKeqMiddleware(instance)) continue\n\n      // 跨 KeqModule 实例去重：\n      // moduleWrapper.metatype 是同一个类引用，Symbol.for 是全局共享 key\n      if (moduleWrapper.metatype[CONFIGURED_SYMBOL]) continue\n      moduleWrapper.metatype[CONFIGURED_SYMBOL] = true\n\n      const consumer = new KeqMiddlewareConsumerImpl()\n      instance.configureKeqMiddleware(consumer)\n      consumer.applyTo(this.keqRequest, this.modulesContainer)\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/constants.ts","../src/keq-middleware-collector.ts","../src/keq-middleware-consumer.ts","../src/keq.module.ts","../src/keq-consumer.ts","../src/decorators/inject-keq-consumer.decorator.ts"],"sourcesContent":["export const KEQ_ROUTES = {\n  ALL: Symbol('KEQ_ROUTES.ALL'),\n} as const\n","import type { KeqExecutionContext, KeqMiddleware, KeqRoute } from 'keq'\nimport { composeRoute, KeqRequest } from 'keq'\nimport picomatch from 'picomatch'\nimport { KEQ_ROUTES } from './constants.js'\nimport type { KeqMiddlewareConfigProxy, KeqRouteTarget, KeqRouteInfo } from './interfaces/keq-middleware-consumer.interface.js'\nimport type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'\n\n\n/** 单条中间件注册条目 */\ninterface MiddlewareEntry {\n  middlewares: Array<KeqNestMiddleware | KeqMiddleware>\n  routes: KeqRouteTarget[]\n  excludedRouteInfos?: KeqRouteInfo[]\n}\n\n/**\n * 中间件收集器，收集中间件配置条目并应用到指定的 {@link KeqRequest} 实例。\n *\n * 通过 `apply()` → `forRoutes()` 链式 API 收集多组中间件条目，\n * 在 `forRoutes()` 被调用时立即将中间件绑定到目标请求。\n *\n * 注意：该类并非 `@Injectable()`，由 Consumer 内部手动创建。\n *\n * @typeParam TConsumer - Consumer 类型（`KeqMiddlewareConsumer` 或 `KeqConsumer<T>`）\n */\nexport class KeqMiddlewareCollector<TConsumer extends object = object> {\n  private entries: MiddlewareEntry[] = []\n\n  constructor(\n    private readonly keqRequest: KeqRequest,\n    private readonly consumer: TConsumer,\n  ) {}\n\n  apply(\n    middlewares: Array<KeqNestMiddleware | KeqMiddleware>,\n  ): KeqMiddlewareConfigProxy {\n    const entry: MiddlewareEntry = { middlewares, routes: [] }\n    const excludedRouteInfos: KeqRouteInfo[] = []\n    this.entries.push(entry)\n\n    const { keqRequest, consumer } = this\n\n    const proxy = {\n      exclude: (...routes: KeqRouteInfo[]) => {\n        excludedRouteInfos.push(...routes)\n        return proxy\n      },\n      forRoutes: (...routes: KeqRouteTarget[]) => {\n        entry.routes = routes\n        if (excludedRouteInfos.length > 0) {\n          entry.excludedRouteInfos = excludedRouteInfos\n        }\n        this.applyTo(keqRequest)\n        return consumer\n      },\n    }\n    return proxy as unknown as KeqMiddlewareConfigProxy\n  }\n\n  /**\n   * 将收集的所有中间件条目解析并应用到指定的 {@link KeqRequest} 实例。\n   */\n  applyTo(keqRequest: KeqRequest): void {\n    for (const entry of this.entries) {\n      let resolved = entry.middlewares.map((m) => this.normalizeMiddleware(m))\n\n      if (entry.excludedRouteInfos && entry.excludedRouteInfos.length > 0) {\n        const excludedRoutes = entry.excludedRouteInfos.map((info) => this.buildRoute(info))\n        resolved = resolved.map((mw) => this.wrapWithExclusion(mw, excludedRoutes))\n      }\n\n      const isGlobal\n        = entry.routes.length === 0 || entry.routes.some((r) => r === KEQ_ROUTES.ALL)\n\n      if (isGlobal) {\n        for (const mw of resolved) keqRequest.use(mw)\n      } else {\n        for (const routeTarget of entry.routes) {\n          if (routeTarget === KEQ_ROUTES.ALL) continue\n          const route = this.buildRoute(routeTarget as KeqRouteInfo)\n          keqRequest.useRouter().route(route, resolved)\n        }\n      }\n    }\n  }\n\n  // ─── 中间件标准化 ────────────────────────────────────\n\n  /**\n   * 标准化中间件：将不同形式的中间件统一为 {@link KeqMiddleware} 函数。\n   * - 若已是 {@link KeqMiddleware} 函数 → 直接返回\n   * - 若为 {@link KeqNestMiddleware} 实例对象 → 包装 `use` 方法为中间件函数\n   */\n  private normalizeMiddleware(\n    m: KeqNestMiddleware | KeqMiddleware,\n  ): KeqMiddleware {\n    if (this.isNestMiddlewareInstance(m)) {\n      return async (ctx, next) => {\n        await m.use(ctx, next)\n      }\n    }\n    return m\n  }\n\n  private isNestMiddlewareInstance(\n    m: KeqNestMiddleware | KeqMiddleware,\n  ): m is KeqNestMiddleware {\n    return typeof m === 'object' && m !== null && 'use' in m\n  }\n\n  // ─── 路由构建 ─────────────────────────────────────────\n\n  private buildRoute(info: KeqRouteInfo): KeqRoute {\n    const routes: KeqRoute[] = []\n    if (info.host) {\n      const host = info.host\n      routes.push((ctx) => ctx.request.url.host === host)\n    }\n    if (info.method) {\n      const method = info.method.toLowerCase()\n      routes.push((ctx) => ctx.request.method.toLowerCase() === method)\n    }\n    if (info.pathname) {\n      const isMatch: (test: string) => boolean = picomatch(info.pathname)\n      routes.push((ctx) => isMatch(ctx.request.url.pathname))\n    }\n    if (routes.length === 1) return routes[0]\n    return composeRoute(routes)\n  }\n\n  private wrapWithExclusion(middleware: KeqMiddleware, excludedRoutes: KeqRoute[]): KeqMiddleware {\n    const excluded: KeqMiddleware = async (ctx, next) => {\n      if (await this.checkExcluded(ctx, excludedRoutes)) {\n        return next()\n      }\n      return middleware(ctx, next)\n    }\n    return excluded\n  }\n\n  private async checkExcluded(\n    ctx: KeqExecutionContext,\n    excludedRoutes: KeqRoute[],\n  ): Promise<boolean> {\n    for (const route of excludedRoutes) {\n      if (await route(ctx)) return true\n    }\n    return false\n  }\n}\n","import { Injectable } from '@nestjs/common'\nimport type { KeqMiddleware } from 'keq'\nimport { KeqRequest } from 'keq'\nimport type { KeqMiddlewareConfigProxy } from './interfaces/keq-middleware-consumer.interface.js'\nimport type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'\nimport { KeqMiddlewareCollector } from './keq-middleware-collector.js'\n\n\n/**\n * 全局中间件消费者，提供 `.apply().forRoutes()` API。\n *\n * `forRoutes()` 返回 `KeqMiddlewareConsumer` 自身，支持链式注册：\n *\n * ```ts\n * consumer\n *   .apply(mw1).forRoutes(KEQ_ROUTES.ALL)\n *   .apply(mw2).forRoutes({ pathname: '/api/*' })\n * ```\n *\n * 模块级别的中间件请使用 `@InjectKeqConsumer(GeneratedModule)` 注入\n * `KeqConsumer<GeneratedModule>`，其 `forRoutes()` 直接作用于目标模块。\n */\n@Injectable()\nexport class KeqMiddlewareConsumer {\n  constructor(private readonly keqRequest: KeqRequest) {}\n\n  apply(\n    ...middlewares: Array<KeqNestMiddleware | KeqMiddleware>\n  ): KeqMiddlewareConfigProxy {\n    const collector = new KeqMiddlewareCollector(this.keqRequest, this)\n    return collector.apply(middlewares)\n  }\n}\n","import { Global, Module } from '@nestjs/common'\nimport { KeqRequest } from 'keq'\nimport { KeqMiddlewareConsumer } from './keq-middleware-consumer.js'\n\n\n@Global()\n@Module({\n  providers: [\n    { provide: KeqRequest, useFactory: () => new KeqRequest() },\n    KeqMiddlewareConsumer,\n  ],\n  exports: [KeqRequest, KeqMiddlewareConsumer],\n})\nexport class KeqModule {}\n","import type { KeqMiddleware } from 'keq'\nimport { KeqRequest } from 'keq'\nimport type { KeqModuleClass, KeqScopedConfigProxy } from './interfaces/keq-middleware-consumer.interface.js'\nimport type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'\nimport { KeqMiddlewareCollector } from './keq-middleware-collector.js'\n\n\n/**\n * 为指定 Keq 模块按路由注册中间件。\n *\n * Keq 模块由 `@keq-request/cli` 生成，通过\n * {@link InjectKeqConsumer} 装饰器注入本实例。\n *\n * @typeParam T - 目标模块类\n *\n * @example\n * ```ts\n * constructor(\n *   \\@InjectKeqConsumer(GeneratedModule) consumer: KeqConsumer<GeneratedModule>,\n * ) {\n *   consumer.apply(authMw).forRoutes('*')\n * }\n * ```\n */\nexport class KeqConsumer<T = KeqModuleClass> {\n  constructor(private readonly keqRequest: KeqRequest) {}\n\n  apply(\n    ...middlewares: Array<KeqNestMiddleware | KeqMiddleware>\n  ): KeqScopedConfigProxy<T> {\n    const collector = new KeqMiddlewareCollector(this.keqRequest, this)\n    return collector.apply(middlewares) as unknown as KeqScopedConfigProxy<T>\n  }\n}\n","import { Inject } from '@nestjs/common'\nimport type { KeqModuleClass } from '../interfaces/keq-middleware-consumer.interface.js'\n\n\n/**\n * 注入绑定到指定 Keq Module 的 `KeqConsumer<T>`。\n *\n * 被注入的 Module Class 必须同时包含 `KEQ_REQUEST` 和 `KEQ_CONSUMER` 静态属性，\n * 两者均由 keq CLI 生成。\n *\n * 使用方式：\n * ```ts\n * constructor(\n *   \\@InjectKeqConsumer(GeneratedModule) consumer: KeqConsumer<GeneratedModule>,\n * ) {\n *   consumer.apply(mw).forRoutes('*')\n * }\n * ```\n *\n * @param moduleClass - 目标 KeqModule 类（需具有 `KEQ_REQUEST` 和 `KEQ_CONSUMER` symbol）\n */\nexport function InjectKeqConsumer<T extends KeqModuleClass>(\n  moduleClass: T,\n): ParameterDecorator {\n  return Inject(moduleClass.KEQ_CONSUMER)\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keq-request/nestjs",
-  "version": "5.0.0-beta.13",
+  "version": "5.0.0-beta.15",
   "description": "Request API write by Typescript for flexibility, readability, and a low learning curve.",
   "keywords": [
     "request",
@@ -43,12 +43,12 @@
     "@types/node": "^20.19.39",
     "@types/picomatch": "^4.0.0",
     "reflect-metadata": "^0.2.2",
-    "keq": "5.0.0-beta.13"
+    "keq": "5.0.0-beta.15"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
     "@nestjs/core": "^11.0.0",
-    "keq": "^5.0.0-beta.13"
+    "keq": "^5.0.0-beta.15"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/decorators/inject-keq-consumer.decorator.ts

@@ -0,0 +1,26 @@
+import { Inject } from '@nestjs/common'
+import type { KeqModuleClass } from '../interfaces/keq-middleware-consumer.interface.js'
+
+
+/**
+ * 注入绑定到指定 Keq Module 的 `KeqConsumer<T>`。
+ *
+ * 被注入的 Module Class 必须同时包含 `KEQ_REQUEST` 和 `KEQ_CONSUMER` 静态属性，
+ * 两者均由 keq CLI 生成。
+ *
+ * 使用方式：
+ * ```ts
+ * constructor(
+ *   \@InjectKeqConsumer(GeneratedModule) consumer: KeqConsumer<GeneratedModule>,
+ * ) {
+ *   consumer.apply(mw).forRoutes('*')
+ * }
+ * ```
+ *
+ * @param moduleClass - 目标 KeqModule 类（需具有 `KEQ_REQUEST` 和 `KEQ_CONSUMER` symbol）
+ */
+export function InjectKeqConsumer<T extends KeqModuleClass>(
+  moduleClass: T,
+): ParameterDecorator {
+  return Inject(moduleClass.KEQ_CONSUMER)
+}

package/src/index.ts

@@ -1,3 +1,6 @@
 export * from './keq.module.js'
+export * from './keq-middleware-consumer.js'
+export * from './keq-consumer.js'
 export * from './constants.js'
 export * from './interfaces/index.js'
+export { InjectKeqConsumer } from './decorators/inject-keq-consumer.decorator.js'

package/src/interfaces/index.ts

@@ -1,4 +1,9 @@
 export type { KeqNestMiddleware } from './keq-nest-middleware.interface.js'
-export type { KeqMiddlewareModule } from './keq-middleware-module.interface.js'
-export type { KeqMiddlewareConsumer, KeqMiddlewareConfigProxy, KeqRouteInfo, KeqModuleClass } from './keq-middleware-consumer.interface.js'
+export type {
+  KeqMiddlewareConfigProxy,
+  KeqScopedConfigProxy,
+  KeqRouteInfo,
+  KeqRouteTarget,
+  KeqModuleClass,
+} from './keq-middleware-consumer.interface.js'
 export type { KeqModuleOptions } from './keq-module-options.interface.js'

package/src/interfaces/keq-middleware-consumer.interface.ts

@@ -1,7 +1,7 @@
 import type { Type } from '@nestjs/common'
-import type { KeqMiddleware } from 'keq'
 import type { KEQ_ROUTES } from '../constants.js'
-import type { KeqNestMiddleware } from './keq-nest-middleware.interface.js'
+import type { KeqMiddlewareConsumer } from '../keq-middleware-consumer.js'
+import type { KeqConsumer } from '../keq-consumer.js'
 
 
 export interface KeqRouteInfo {
@@ -12,13 +12,19 @@ export interface KeqRouteInfo {
 
 export interface KeqModuleClass extends Type<any> {
   readonly KEQ_REQUEST: symbol
+  readonly KEQ_CONSUMER: symbol
 }
 
+/** forRoutes() 接受的路由目标（不再包含 KeqModuleClass，模块绑定通过 @InjectKeqConsumer 实现） */
+export type KeqRouteTarget = typeof KEQ_ROUTES.ALL | KeqRouteInfo
+
 export interface KeqMiddlewareConfigProxy {
   exclude(...routes: KeqRouteInfo[]): KeqMiddlewareConfigProxy
-  forRoutes(...routes: Array<typeof KEQ_ROUTES.ALL | KeqRouteInfo | KeqModuleClass>): KeqMiddlewareConsumer
+  forRoutes(...routes: KeqRouteTarget[]): KeqMiddlewareConsumer
 }
 
-export interface KeqMiddlewareConsumer {
-  apply(...middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>): KeqMiddlewareConfigProxy
+/** 模块绑定 Consumer 的配置代理，forRoutes() 返回 KeqConsumer<T> */
+export interface KeqScopedConfigProxy<T = KeqModuleClass> {
+  exclude(...routes: KeqRouteInfo[]): KeqScopedConfigProxy<T>
+  forRoutes(...routes: KeqRouteTarget[]): KeqConsumer<T>
 }

package/src/keq-consumer.ts

@@ -0,0 +1,34 @@
+import type { KeqMiddleware } from 'keq'
+import { KeqRequest } from 'keq'
+import type { KeqModuleClass, KeqScopedConfigProxy } from './interfaces/keq-middleware-consumer.interface.js'
+import type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'
+import { KeqMiddlewareCollector } from './keq-middleware-collector.js'
+
+
+/**
+ * 为指定 Keq 模块按路由注册中间件。
+ *
+ * Keq 模块由 `@keq-request/cli` 生成，通过
+ * {@link InjectKeqConsumer} 装饰器注入本实例。
+ *
+ * @typeParam T - 目标模块类
+ *
+ * @example
+ * ```ts
+ * constructor(
+ *   \@InjectKeqConsumer(GeneratedModule) consumer: KeqConsumer<GeneratedModule>,
+ * ) {
+ *   consumer.apply(authMw).forRoutes('*')
+ * }
+ * ```
+ */
+export class KeqConsumer<T = KeqModuleClass> {
+  constructor(private readonly keqRequest: KeqRequest) {}
+
+  apply(
+    ...middlewares: Array<KeqNestMiddleware | KeqMiddleware>
+  ): KeqScopedConfigProxy<T> {
+    const collector = new KeqMiddlewareCollector(this.keqRequest, this)
+    return collector.apply(middlewares) as unknown as KeqScopedConfigProxy<T>
+  }
+}

package/src/keq-middleware-collector.ts

@@ -0,0 +1,150 @@
+import type { KeqExecutionContext, KeqMiddleware, KeqRoute } from 'keq'
+import { composeRoute, KeqRequest } from 'keq'
+import picomatch from 'picomatch'
+import { KEQ_ROUTES } from './constants.js'
+import type { KeqMiddlewareConfigProxy, KeqRouteTarget, KeqRouteInfo } from './interfaces/keq-middleware-consumer.interface.js'
+import type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'
+
+
+/** 单条中间件注册条目 */
+interface MiddlewareEntry {
+  middlewares: Array<KeqNestMiddleware | KeqMiddleware>
+  routes: KeqRouteTarget[]
+  excludedRouteInfos?: KeqRouteInfo[]
+}
+
+/**
+ * 中间件收集器，收集中间件配置条目并应用到指定的 {@link KeqRequest} 实例。
+ *
+ * 通过 `apply()` → `forRoutes()` 链式 API 收集多组中间件条目，
+ * 在 `forRoutes()` 被调用时立即将中间件绑定到目标请求。
+ *
+ * 注意：该类并非 `@Injectable()`，由 Consumer 内部手动创建。
+ *
+ * @typeParam TConsumer - Consumer 类型（`KeqMiddlewareConsumer` 或 `KeqConsumer<T>`）
+ */
+export class KeqMiddlewareCollector<TConsumer extends object = object> {
+  private entries: MiddlewareEntry[] = []
+
+  constructor(
+    private readonly keqRequest: KeqRequest,
+    private readonly consumer: TConsumer,
+  ) {}
+
+  apply(
+    middlewares: Array<KeqNestMiddleware | KeqMiddleware>,
+  ): KeqMiddlewareConfigProxy {
+    const entry: MiddlewareEntry = { middlewares, routes: [] }
+    const excludedRouteInfos: KeqRouteInfo[] = []
+    this.entries.push(entry)
+
+    const { keqRequest, consumer } = this
+
+    const proxy = {
+      exclude: (...routes: KeqRouteInfo[]) => {
+        excludedRouteInfos.push(...routes)
+        return proxy
+      },
+      forRoutes: (...routes: KeqRouteTarget[]) => {
+        entry.routes = routes
+        if (excludedRouteInfos.length > 0) {
+          entry.excludedRouteInfos = excludedRouteInfos
+        }
+        this.applyTo(keqRequest)
+        return consumer
+      },
+    }
+    return proxy as unknown as KeqMiddlewareConfigProxy
+  }
+
+  /**
+   * 将收集的所有中间件条目解析并应用到指定的 {@link KeqRequest} 实例。
+   */
+  applyTo(keqRequest: KeqRequest): void {
+    for (const entry of this.entries) {
+      let resolved = entry.middlewares.map((m) => this.normalizeMiddleware(m))
+
+      if (entry.excludedRouteInfos && entry.excludedRouteInfos.length > 0) {
+        const excludedRoutes = entry.excludedRouteInfos.map((info) => this.buildRoute(info))
+        resolved = resolved.map((mw) => this.wrapWithExclusion(mw, excludedRoutes))
+      }
+
+      const isGlobal
+        = entry.routes.length === 0 || entry.routes.some((r) => r === KEQ_ROUTES.ALL)
+
+      if (isGlobal) {
+        for (const mw of resolved) keqRequest.use(mw)
+      } else {
+        for (const routeTarget of entry.routes) {
+          if (routeTarget === KEQ_ROUTES.ALL) continue
+          const route = this.buildRoute(routeTarget as KeqRouteInfo)
+          keqRequest.useRouter().route(route, resolved)
+        }
+      }
+    }
+  }
+
+  // ─── 中间件标准化 ────────────────────────────────────
+
+  /**
+   * 标准化中间件：将不同形式的中间件统一为 {@link KeqMiddleware} 函数。
+   * - 若已是 {@link KeqMiddleware} 函数 → 直接返回
+   * - 若为 {@link KeqNestMiddleware} 实例对象 → 包装 `use` 方法为中间件函数
+   */
+  private normalizeMiddleware(
+    m: KeqNestMiddleware | KeqMiddleware,
+  ): KeqMiddleware {
+    if (this.isNestMiddlewareInstance(m)) {
+      return async (ctx, next) => {
+        await m.use(ctx, next)
+      }
+    }
+    return m
+  }
+
+  private isNestMiddlewareInstance(
+    m: KeqNestMiddleware | KeqMiddleware,
+  ): m is KeqNestMiddleware {
+    return typeof m === 'object' && m !== null && 'use' in m
+  }
+
+  // ─── 路由构建 ─────────────────────────────────────────
+
+  private buildRoute(info: KeqRouteInfo): KeqRoute {
+    const routes: KeqRoute[] = []
+    if (info.host) {
+      const host = info.host
+      routes.push((ctx) => ctx.request.url.host === host)
+    }
+    if (info.method) {
+      const method = info.method.toLowerCase()
+      routes.push((ctx) => ctx.request.method.toLowerCase() === method)
+    }
+    if (info.pathname) {
+      const isMatch: (test: string) => boolean = picomatch(info.pathname)
+      routes.push((ctx) => isMatch(ctx.request.url.pathname))
+    }
+    if (routes.length === 1) return routes[0]
+    return composeRoute(routes)
+  }
+
+  private wrapWithExclusion(middleware: KeqMiddleware, excludedRoutes: KeqRoute[]): KeqMiddleware {
+    const excluded: KeqMiddleware = async (ctx, next) => {
+      if (await this.checkExcluded(ctx, excludedRoutes)) {
+        return next()
+      }
+      return middleware(ctx, next)
+    }
+    return excluded
+  }
+
+  private async checkExcluded(
+    ctx: KeqExecutionContext,
+    excludedRoutes: KeqRoute[],
+  ): Promise<boolean> {
+    for (const route of excludedRoutes) {
+      if (await route(ctx)) return true
+    }
+    return false
+  }
+}