@keq-request/nestjs 5.0.0-beta.1 → 5.0.0-beta.10

package/.turbo/turbo-build.log

@@ -1,10 +1,10 @@
 
-> @keq-request/nestjs@5.0.0-beta.1 build /home/runner/work/keq/keq/packages/nestjs
+> @keq-request/nestjs@5.0.0-beta.10 build /home/runner/work/keq/keq/packages/nestjs
 > tsdown
 
 ℹ tsdown v0.21.10 powered by rolldown v1.0.0-rc.17
 ℹ config file: /home/runner/work/keq/keq/packages/nestjs/tsdown.config.ts 
-(node:2773) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/keq/keq/packages/nestjs/tsdown.config.ts?no-cache=119757d8-e689-4e58-9a81-69c968dc25b8 is not specified and it doesn't parse as CommonJS.
+(node:2742) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/keq/keq/packages/nestjs/tsdown.config.ts?no-cache=8189b2cf-8eb7-4535-86e4-76dbf1cebae5 is not specified and it doesn't parse as CommonJS.
 Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
 To eliminate this warning, add "type": "module" to /home/runner/work/keq/keq/packages/nestjs/package.json.
 (Use `node --trace-warnings ...` to show where the warning was created)
@@ -12,25 +12,25 @@ To eliminate this warning, add "type": "module" to /home/runner/work/keq/keq/pac
 ℹ target: node20
 ℹ tsconfig: tsconfig.lib.json
 ℹ Build start
-ℹ [CJS] dist/index.js      2.35 kB │ gzip: 1.00 kB
-ℹ [CJS] dist/index.js.map  3.54 kB │ gzip: 1.35 kB
-ℹ [CJS] 2 files, total: 5.89 kB
+ℹ [CJS] dist/index.js      5.83 kB │ gzip: 2.01 kB
+ℹ [CJS] dist/index.js.map  7.28 kB │ gzip: 2.38 kB
+ℹ [CJS] 2 files, total: 13.11 kB
 [PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `tsdown:deps`. See https://rolldown.rs/options/checks#plugintimings for more details.
 
-ℹ [CJS] dist/index.d.ts.map  0.54 kB │ gzip: 0.30 kB
-ℹ [CJS] dist/index.d.ts      2.17 kB │ gzip: 0.89 kB
-ℹ [CJS] 2 files, total: 2.71 kB
+ℹ [ESM] dist/index.mjs        4.54 kB │ gzip: 1.57 kB
+ℹ [ESM] dist/index.mjs.map    7.21 kB │ gzip: 2.36 kB
+ℹ [ESM] dist/index.d.mts.map  0.99 kB │ gzip: 0.43 kB
+ℹ [ESM] dist/index.d.mts      1.86 kB │ gzip: 0.66 kB
+ℹ [ESM] 4 files, total: 14.60 kB
+[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `rolldown-plugin-dts:generate`. See https://rolldown.rs/options/checks#plugintimings for more details.
+
+✔ Build complete in 5031ms
+ℹ [CJS] dist/index.d.ts.map  0.99 kB │ gzip: 0.43 kB
+ℹ [CJS] dist/index.d.ts      1.86 kB │ gzip: 0.65 kB
+ℹ [CJS] 2 files, total: 2.85 kB
+✔ Build complete in 5034ms
 [PLUGIN_TIMINGS] Warning: Your build spent significant time in plugins. Here is a breakdown:
-  - rolldown-plugin-dts:generate (65%)
-  - tsdown:deps (32%)
+  - rolldown-plugin-dts:generate (46%)
+  - tsdown:deps (44%)
 See https://rolldown.rs/options/checks#plugintimings for more details.
 
-✔ Build complete in 4279ms
-ℹ [ESM] dist/index.mjs        2.17 kB │ gzip: 0.92 kB
-ℹ [ESM] dist/index.mjs.map    3.49 kB │ gzip: 1.34 kB
-ℹ [ESM] dist/index.d.mts.map  0.54 kB │ gzip: 0.30 kB
-ℹ [ESM] dist/index.d.mts      2.17 kB │ gzip: 0.89 kB
-ℹ [ESM] 4 files, total: 8.37 kB
-[PLUGIN_TIMINGS] Warning: Your build spent significant time in plugin `rolldown-plugin-dts:generate`. See https://rolldown.rs/options/checks#plugintimings for more details.
-
-✔ Build complete in 4280ms

package/CHANGELOG.md

@@ -1,5 +1,64 @@
 # @keq-request/nestjs
 
+## 5.0.0-beta.10
+
+### Minor Changes
+
+- 2e13e75: **BREAKING CHANGE:** Remove `request` option from `KeqModuleOptions`, use fork-based instance isolation instead.
+
+### Patch Changes
+
+- Updated dependencies [95908fd]
+  - keq@5.0.0-beta.10
+
+## 5.0.0-beta.9
+
+### Patch Changes
+
+- keq@5.0.0-beta.9
+
+## 5.0.0-beta.8
+
+### Patch Changes
+
+- keq@5.0.0-beta.8
+
+## 5.0.0-beta.7
+
+### Patch Changes
+
+- keq@5.0.0-beta.7
+
+## 5.0.0-beta.6
+
+### Patch Changes
+
+- keq@5.0.0-beta.6
+
+## 5.0.0-beta.5
+
+### Patch Changes
+
+- keq@5.0.0-beta.5
+
+## 5.0.0-beta.4
+
+### Patch Changes
+
+- keq@5.0.0-beta.4
+
+## 5.0.0-beta.3
+
+### Patch Changes
+
+- keq@5.0.0-beta.3
+
+## 5.0.0-beta.2
+
+### Patch Changes
+
+- keq@5.0.0-beta.2
+
 ## 5.0.0-beta.1
 
 ### Minor Changes

package/dist/index.d.mts

@@ -1,62 +1,52 @@
-import { KeqMiddleware } from "keq";
-import * as _$_nestjs_common0 from "@nestjs/common";
-import { DynamicModule } from "@nestjs/common";
+import { OnModuleInit, Type } from "@nestjs/common";
+import { ModuleRef, ModulesContainer } from "@nestjs/core";
+import { KeqExecutionContext, KeqMiddleware, KeqNext, KeqRequest } from "keq";
 
-//#region src/types/keq-module-options.d.ts
-interface KeqModuleOptions {
-  middlewares?: KeqMiddleware[];
+//#region src/keq.module.d.ts
+declare class KeqModule implements OnModuleInit {
+  private readonly modulesContainer;
+  private readonly moduleRef;
+  private readonly keqRequest;
+  constructor(modulesContainer: ModulesContainer, moduleRef: ModuleRef, keqRequest: KeqRequest);
+  onModuleInit(): void;
 }
 //#endregion
-//#region src/keq.module-definition.d.ts
-declare const ConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: _$_nestjs_common0.ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
+//#region src/constants.d.ts
+declare const KEQ_ROUTES: {
+  readonly ALL: symbol;
+};
 //#endregion
-//#region src/keq.module.d.ts
-/**
- * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS
- *
- * This module is global, so KeqRequest can be injected anywhere in your application
- * without needing to import the module in every feature module.
- *
- * @example
- * ```typescript
- * // Synchronous registration
- * KeqModule.register({
- *   middlewares: [...]
- * })
- *
- * // Asynchronous registration
- * KeqModule.registerAsync({
- *   imports: [ConfigModule],
- *   useFactory: (config: ConfigService) => ({
- *     middlewares: [...]
- *   }),
- *   inject: [ConfigService]
- * })
- *
- * // Inject in service
- * class UserService {
- *   constructor(private readonly keqRequest: KeqRequest) {}
- *   async getUser(id: string) {
- *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')
- *   }
- * }
- * ```
- */
-declare class KeqModule extends ConfigurableModuleClass {
-  /**
-   * Register the module with synchronous options
-   * @param options - Configuration options including middlewares
-   * @returns DynamicModule with KeqRequest provider
-   */
-  static register(options: typeof OPTIONS_TYPE): DynamicModule;
-  /**
-   * Register the module with asynchronous options
-   * Useful when you need to inject dependencies like ConfigService
-   * @param options - Async configuration options
-   * @returns DynamicModule with KeqRequest provider
-   */
-  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
+//#region src/interfaces/keq-nest-middleware.interface.d.ts
+interface KeqNestMiddleware {
+  use(ctx: KeqExecutionContext, next: KeqNext): void | PromiseLike<void>;
+}
+//#endregion
+//#region src/interfaces/keq-middleware-consumer.interface.d.ts
+interface KeqRouteInfo {
+  host?: string;
+  method?: string;
+  pathname?: string;
+}
+interface KeqModuleClass {
+  readonly KEQ_REQUEST: symbol;
+}
+interface KeqMiddlewareConfigProxy {
+  forRoutes(...routes: Array<typeof KEQ_ROUTES.ALL | KeqRouteInfo | KeqModuleClass>): KeqMiddlewareConsumer;
+}
+interface KeqMiddlewareConsumer {
+  apply(...middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>): KeqMiddlewareConfigProxy;
+}
+//#endregion
+//#region src/interfaces/keq-middleware-module.interface.d.ts
+interface KeqMiddlewareModule {
+  configureKeqMiddleware(consumer: KeqMiddlewareConsumer): void;
+}
+//#endregion
+//#region src/interfaces/keq-module-options.interface.d.ts
+interface KeqModuleOptions {
+  middlewares?: KeqMiddleware[];
+  isolate?: boolean;
 }
 //#endregion
-export { KeqModule, KeqModuleOptions };
+export { KEQ_ROUTES, type KeqMiddlewareConfigProxy, type KeqMiddlewareConsumer, type KeqMiddlewareModule, KeqModule, type KeqModuleClass, type KeqModuleOptions, type KeqNestMiddleware, type KeqRouteInfo };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types/keq-module-options.ts","../src/keq.module-definition.ts","../src/keq.module.ts"],"mappings":";;;;;UAGiB,gBAAA;EACf,WAAA,GAAc,aAAA;AAAA;;;cCEd,uBAAA,EAAuB,iBAAA,CAAA,qBAAA,CAAA,gBAAA,6BAAA,oBAAA,mBAAA,YAAA,EAEX,gBAAA,GAAA,OAAA,MAAA,kBAAA,EACM,iBAAA,CAAA,8BAAA,CAAA,gBAAA,cAAA,OAAA;;;;;;ADNpB;;;;;;;;ACEA;;;;;;;;;;;;;;;;;;;;cCsDa,SAAA,SAAkB,uBAAA;EDnD7B;;;;;EAAA,OCyDO,QAAA,CAAS,OAAA,SAAgB,YAAA,GAAe,aAAA;EAN1B;;;;;;EAAA,OAoBd,aAAA,CAAc,OAAA,SAAgB,kBAAA,GAAqB,aAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/keq.module.ts","../src/constants.ts","../src/interfaces/keq-nest-middleware.interface.ts","../src/interfaces/keq-middleware-consumer.interface.ts","../src/interfaces/keq-middleware-module.interface.ts","../src/interfaces/keq-module-options.interface.ts"],"mappings":";;;;;cAYa,SAAA,YAAqB,YAAA;EAAA,iBAEb,gBAAA;EAAA,iBACA,SAAA;EAAA,iBACA,UAAA;cAFA,gBAAA,EAAkB,gBAAA,EAClB,SAAA,EAAW,SAAA,EACX,UAAA,EAAY,UAAA;EAG/B,YAAA,CAAA;AAAA;;;cCnBW,UAAA;EAAA,SAEH,GAAA;AAAA;;;UCCO,iBAAA;EACf,GAAA,CAAI,GAAA,EAAK,mBAAA,EAAqB,IAAA,EAAM,OAAA,UAAiB,WAAA;AAAA;;;UCEtC,YAAA;EACf,IAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,UAGe,cAAA;EAAA,SACN,WAAA;AAAA;AAAA,UAGM,wBAAA;EACf,SAAA,IAAa,MAAA,EAAQ,KAAA,QAAa,UAAA,CAAW,GAAA,GAAM,YAAA,GAAe,cAAA,IAAkB,qBAAA;AAAA;AAAA,UAGrE,qBAAA;EACf,KAAA,IAAS,WAAA,EAAa,KAAA,CAAM,IAAA,CAAK,iBAAA,IAAqB,aAAA,IAAiB,wBAAA;AAAA;;;UClBxD,mBAAA;EACf,sBAAA,CAAuB,QAAA,EAAU,qBAAA;AAAA;;;UCDlB,gBAAA;EACf,WAAA,GAAc,aAAA;EACd,OAAA;AAAA"}

package/dist/index.d.ts

@@ -1,62 +1,52 @@
-import * as _$_nestjs_common0 from "@nestjs/common";
-import { DynamicModule } from "@nestjs/common";
-import { KeqMiddleware } from "keq";
+import { OnModuleInit, Type } from "@nestjs/common";
+import { ModuleRef, ModulesContainer } from "@nestjs/core";
+import { KeqExecutionContext, KeqMiddleware, KeqNext, KeqRequest } from "keq";
 
-//#region src/types/keq-module-options.d.ts
-interface KeqModuleOptions {
-  middlewares?: KeqMiddleware[];
+//#region src/keq.module.d.ts
+declare class KeqModule implements OnModuleInit {
+  private readonly modulesContainer;
+  private readonly moduleRef;
+  private readonly keqRequest;
+  constructor(modulesContainer: ModulesContainer, moduleRef: ModuleRef, keqRequest: KeqRequest);
+  onModuleInit(): void;
 }
 //#endregion
-//#region src/keq.module-definition.d.ts
-declare const ConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: _$_nestjs_common0.ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
+//#region src/constants.d.ts
+declare const KEQ_ROUTES: {
+  readonly ALL: symbol;
+};
 //#endregion
-//#region src/keq.module.d.ts
-/**
- * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS
- *
- * This module is global, so KeqRequest can be injected anywhere in your application
- * without needing to import the module in every feature module.
- *
- * @example
- * ```typescript
- * // Synchronous registration
- * KeqModule.register({
- *   middlewares: [...]
- * })
- *
- * // Asynchronous registration
- * KeqModule.registerAsync({
- *   imports: [ConfigModule],
- *   useFactory: (config: ConfigService) => ({
- *     middlewares: [...]
- *   }),
- *   inject: [ConfigService]
- * })
- *
- * // Inject in service
- * class UserService {
- *   constructor(private readonly keqRequest: KeqRequest) {}
- *   async getUser(id: string) {
- *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')
- *   }
- * }
- * ```
- */
-declare class KeqModule extends ConfigurableModuleClass {
-  /**
-   * Register the module with synchronous options
-   * @param options - Configuration options including middlewares
-   * @returns DynamicModule with KeqRequest provider
-   */
-  static register(options: typeof OPTIONS_TYPE): DynamicModule;
-  /**
-   * Register the module with asynchronous options
-   * Useful when you need to inject dependencies like ConfigService
-   * @param options - Async configuration options
-   * @returns DynamicModule with KeqRequest provider
-   */
-  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule;
+//#region src/interfaces/keq-nest-middleware.interface.d.ts
+interface KeqNestMiddleware {
+  use(ctx: KeqExecutionContext, next: KeqNext): void | PromiseLike<void>;
+}
+//#endregion
+//#region src/interfaces/keq-middleware-consumer.interface.d.ts
+interface KeqRouteInfo {
+  host?: string;
+  method?: string;
+  pathname?: string;
+}
+interface KeqModuleClass {
+  readonly KEQ_REQUEST: symbol;
+}
+interface KeqMiddlewareConfigProxy {
+  forRoutes(...routes: Array<typeof KEQ_ROUTES.ALL | KeqRouteInfo | KeqModuleClass>): KeqMiddlewareConsumer;
+}
+interface KeqMiddlewareConsumer {
+  apply(...middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>): KeqMiddlewareConfigProxy;
+}
+//#endregion
+//#region src/interfaces/keq-middleware-module.interface.d.ts
+interface KeqMiddlewareModule {
+  configureKeqMiddleware(consumer: KeqMiddlewareConsumer): void;
+}
+//#endregion
+//#region src/interfaces/keq-module-options.interface.d.ts
+interface KeqModuleOptions {
+  middlewares?: KeqMiddleware[];
+  isolate?: boolean;
 }
 //#endregion
-export { KeqModule, KeqModuleOptions };
+export { KEQ_ROUTES, type KeqMiddlewareConfigProxy, type KeqMiddlewareConsumer, type KeqMiddlewareModule, KeqModule, type KeqModuleClass, type KeqModuleOptions, type KeqNestMiddleware, type KeqRouteInfo };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types/keq-module-options.ts","../src/keq.module-definition.ts","../src/keq.module.ts"],"mappings":";;;;;UAGiB,gBAAA;EACf,WAAA,GAAc,aAAA;AAAA;;;cCEd,uBAAA,EAAuB,iBAAA,CAAA,qBAAA,CAAA,gBAAA,6BAAA,oBAAA,mBAAA,YAAA,EAEX,gBAAA,GAAA,OAAA,MAAA,kBAAA,EACM,iBAAA,CAAA,8BAAA,CAAA,gBAAA,cAAA,OAAA;;;;;;ADNpB;;;;;;;;ACEA;;;;;;;;;;;;;;;;;;;;cCsDa,SAAA,SAAkB,uBAAA;EDnD7B;;;;;EAAA,OCyDO,QAAA,CAAS,OAAA,SAAgB,YAAA,GAAe,aAAA;EAN1B;;;;;;EAAA,OAoBd,aAAA,CAAc,OAAA,SAAgB,kBAAA,GAAqB,aAAA;AAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/keq.module.ts","../src/constants.ts","../src/interfaces/keq-nest-middleware.interface.ts","../src/interfaces/keq-middleware-consumer.interface.ts","../src/interfaces/keq-middleware-module.interface.ts","../src/interfaces/keq-module-options.interface.ts"],"mappings":";;;;;cAYa,SAAA,YAAqB,YAAA;EAAA,iBAEb,gBAAA;EAAA,iBACA,SAAA;EAAA,iBACA,UAAA;cAFA,gBAAA,EAAkB,gBAAA,EAClB,SAAA,EAAW,SAAA,EACX,UAAA,EAAY,UAAA;EAG/B,YAAA,CAAA;AAAA;;;cCnBW,UAAA;EAAA,SAEH,GAAA;AAAA;;;UCCO,iBAAA;EACf,GAAA,CAAI,GAAA,EAAK,mBAAA,EAAqB,IAAA,EAAM,OAAA,UAAiB,WAAA;AAAA;;;UCEtC,YAAA;EACf,IAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,UAGe,cAAA;EAAA,SACN,WAAA;AAAA;AAAA,UAGM,wBAAA;EACf,SAAA,IAAa,MAAA,EAAQ,KAAA,QAAa,UAAA,CAAW,GAAA,GAAM,YAAA,GAAe,cAAA,IAAkB,qBAAA;AAAA;AAAA,UAGrE,qBAAA;EACf,KAAA,IAAS,WAAA,EAAa,KAAA,CAAM,IAAA,CAAK,iBAAA,IAAqB,aAAA,IAAiB,wBAAA;AAAA;;;UClBxD,mBAAA;EACf,sBAAA,CAAuB,QAAA,EAAU,qBAAA;AAAA;;;UCDlB,gBAAA;EACf,WAAA,GAAc,aAAA;EACd,OAAA;AAAA"}

package/dist/index.js

@@ -1,8 +1,107 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-let keq = require("keq");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
 let _nestjs_common = require("@nestjs/common");
-//#region src/keq.module-definition.ts
-const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new _nestjs_common.ConfigurableModuleBuilder().build();
+let _nestjs_core = require("@nestjs/core");
+let keq = require("keq");
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch);
+//#region src/constants.ts
+const KEQ_ROUTES = { ALL: Symbol("KEQ_ROUTES.ALL") };
+//#endregion
+//#region src/keq-middleware-consumer.ts
+var KeqMiddlewareConsumerImpl = class {
+	entries = [];
+	apply(...middlewares) {
+		const entry = {
+			middlewares,
+			routes: []
+		};
+		this.entries.push(entry);
+		return { forRoutes: (...routes) => {
+			entry.routes = routes;
+			return this;
+		} };
+	}
+	applyTo(keqRequest, moduleRef) {
+		for (const entry of this.entries) {
+			const resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, moduleRef));
+			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 = moduleRef.get(routeTarget.KEQ_REQUEST, { strict: false });
+					if (targetRequest) for (const mw of resolved) targetRequest.use(mw);
+				} else {
+					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;
+	}
+	resolveMiddleware(m, moduleRef) {
+		if (this.isNestMiddlewareClass(m)) {
+			const instance = moduleRef.get(m, { strict: false });
+			return async (ctx, next) => {
+				await instance.use(ctx, next);
+			};
+		}
+		return m;
+	}
+	buildRoute(info) {
+		const routes = [];
+		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 = (0, picomatch.default)(info.pathname);
+			routes.push((ctx) => isMatch(ctx.request.url.pathname));
+		}
+		if (routes.length === 1) return routes[0];
+		return (0, keq.composeRoute)(routes);
+	}
+};
+//#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);
+}
 //#endregion
 //#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -13,46 +112,41 @@ function __decorate(decorators, target, key, desc) {
 }
 //#endregion
 //#region src/keq.module.ts
-/**
-* Provider that creates and configures a KeqRequest instance
-* Applies any middlewares defined in the module options
-*/
-const requestProvider = {
-	provide: keq.KeqRequest,
-	useFactory: (config) => {
-		const request = new keq.KeqRequest();
-		if (config.middlewares) for (const middleware of config.middlewares) request.use(middleware);
-		return request;
-	},
-	inject: [MODULE_OPTIONS_TOKEN]
-};
-let KeqModule = class KeqModule extends ConfigurableModuleClass {
-	/**
-	* Register the module with synchronous options
-	* @param options - Configuration options including middlewares
-	* @returns DynamicModule with KeqRequest provider
-	*/
-	static register(options) {
-		const mo = super.register(options);
-		mo.providers.push(requestProvider);
-		mo.global = true;
-		return mo;
-	}
-	/**
-	* Register the module with asynchronous options
-	* Useful when you need to inject dependencies like ConfigService
-	* @param options - Async configuration options
-	* @returns DynamicModule with KeqRequest provider
-	*/
-	static registerAsync(options) {
-		const mo = super.registerAsync(options);
-		mo.providers.push(requestProvider);
-		mo.global = true;
-		return mo;
+var _ref, _ref2, _ref3;
+let KeqModule = class KeqModule {
+	constructor(modulesContainer, moduleRef, keqRequest) {
+		this.modulesContainer = modulesContainer;
+		this.moduleRef = moduleRef;
+		this.keqRequest = keqRequest;
+	}
+	onModuleInit() {
+		for (const [, moduleWrapper] of this.modulesContainer) {
+			const instance = moduleWrapper.instance;
+			if (hasConfigureKeqMiddleware(instance)) {
+				const consumer = new KeqMiddlewareConsumerImpl();
+				instance.configureKeqMiddleware(consumer);
+				consumer.applyTo(this.keqRequest, this.moduleRef);
+			}
+		}
 	}
 };
-KeqModule = __decorate([(0, _nestjs_common.Global)()], KeqModule);
+KeqModule = __decorate([
+	(0, _nestjs_common.Global)(),
+	(0, _nestjs_common.Module)({
+		providers: [{
+			provide: keq.KeqRequest,
+			useFactory: () => new keq.KeqRequest()
+		}],
+		exports: [keq.KeqRequest]
+	}),
+	__decorateMetadata("design:paramtypes", [
+		typeof (_ref = typeof _nestjs_core.ModulesContainer !== "undefined" && _nestjs_core.ModulesContainer) === "function" ? _ref : Object,
+		typeof (_ref2 = typeof _nestjs_core.ModuleRef !== "undefined" && _nestjs_core.ModuleRef) === "function" ? _ref2 : Object,
+		typeof (_ref3 = typeof keq.KeqRequest !== "undefined" && keq.KeqRequest) === "function" ? _ref3 : Object
+	])
+], KeqModule);
 //#endregion
+exports.KEQ_ROUTES = KEQ_ROUTES;
 Object.defineProperty(exports, "KeqModule", {
 	enumerable: true,
 	get: function() {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["ConfigurableModuleBuilder","KeqRequest"],"sources":["../src/keq.module-definition.ts","../src/keq.module.ts"],"sourcesContent":["\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n","\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Global, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\n\n/**\n * Provider that creates and configures a KeqRequest instance\n * Applies any middlewares defined in the module options\n */\nconst requestProvider: Provider = {\n  provide: KeqRequest,\n  useFactory: (config: KeqModuleOptions) => {\n    const request = new KeqRequest()\n\n    if (config.middlewares) {\n      for (const middleware of config.middlewares) {\n        request.use(middleware)\n      }\n    }\n\n    return request\n  },\n  inject: [MODULE_OPTIONS_TOKEN],\n}\n\n/**\n * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS\n *\n * This module is global, so KeqRequest can be injected anywhere in your application\n * without needing to import the module in every feature module.\n *\n * @example\n * ```typescript\n * // Synchronous registration\n * KeqModule.register({\n *   middlewares: [...]\n * })\n *\n * // Asynchronous registration\n * KeqModule.registerAsync({\n *   imports: [ConfigModule],\n *   useFactory: (config: ConfigService) => ({\n *     middlewares: [...]\n *   }),\n *   inject: [ConfigService]\n * })\n *\n * // Inject in service\n * class UserService {\n *   constructor(private readonly keqRequest: KeqRequest) {}\n *   async getUser(id: string) {\n *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')\n *   }\n * }\n * ```\n */\n@Global()\nexport class KeqModule extends ConfigurableModuleClass {\n  /**\n   * Register the module with synchronous options\n   * @param options - Configuration options including middlewares\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n\n  /**\n   * Register the module with asynchronous options\n   * Useful when you need to inject dependencies like ConfigService\n   * @param options - Async configuration options\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n}\n"],"mappings":";;;;AAKA,MAAa,EACX,yBACA,sBACA,cACA,uBACE,IAAIA,eAAAA,2BAA6C,CAAC,OAAO;;;;;;;;;;;;;;;ACC7D,MAAM,kBAA4B;CAChC,SAASC,IAAAA;CACT,aAAa,WAA6B;EACxC,MAAM,UAAU,IAAIA,IAAAA,YAAY;AAEhC,MAAI,OAAO,YACT,MAAK,MAAM,cAAc,OAAO,YAC9B,SAAQ,IAAI,WAAW;AAI3B,SAAO;;CAET,QAAQ,CAAC,qBAAqB;CAC/B;AAkCM,IAAA,YAAA,MAAM,kBAAkB,wBAAwB;;;;;;CAMrD,OAAO,SAAS,SAA6C;EAC3D,MAAM,KAAK,MAAM,SAAS,QAAQ;AAClC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;;;;;;CAST,OAAO,cAAc,SAAmD;EACtE,MAAM,KAAK,MAAM,cAAc,QAAQ;AACvC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;oDA1BF,CAAA,EAAA,UAAA"}
+{"version":3,"file":"index.js","names":["KeqRequest"],"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 { ModuleRef } from '@nestjs/core'\nimport type { 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}\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    this.entries.push(entry)\n    return {\n      forRoutes: (...routes) => {\n        entry.routes = routes\n        return this\n      },\n    }\n  }\n\n  applyTo(keqRequest: KeqRequest, moduleRef: ModuleRef): void {\n    for (const entry of this.entries) {\n      const resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, moduleRef))\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 = moduleRef.get<KeqRequest>(routeTarget.KEQ_REQUEST, { strict: false })\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 resolveMiddleware(m: Type<KeqNestMiddleware> | KeqMiddleware, moduleRef: ModuleRef): KeqMiddleware {\n    if (this.isNestMiddlewareClass(m)) {\n      const instance = moduleRef.get<KeqNestMiddleware>(m, { strict: false })\n      return async (ctx, next) => {\n        await instance.use(ctx, next)\n      }\n    }\n    return m\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","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 } from '@nestjs/common'\nimport { ModulesContainer, ModuleRef } 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@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 moduleRef: ModuleRef,\n    private readonly keqRequest: KeqRequest,\n  ) {}\n\n  onModuleInit(): void {\n    for (const [, moduleWrapper] of this.modulesContainer) {\n      const instance = moduleWrapper.instance\n      if (hasConfigureKeqMiddleware(instance)) {\n        const consumer = new KeqMiddlewareConsumerImpl()\n        instance.configureKeqMiddleware(consumer)\n        consumer.applyTo(this.keqRequest, this.moduleRef)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,MAAa,aAAa,EACxB,KAAK,OAAO,iBAAiB,EAC9B;;;ACaD,IAAa,4BAAb,MAAwE;CACtE,UAAqC,EAAE;CAEvC,MAAM,GAAG,aAAuF;EAC9F,MAAM,QAAyB;GAAE;GAAa,QAAQ,EAAE;GAAE;AAC1D,OAAK,QAAQ,KAAK,MAAM;AACxB,SAAO,EACL,YAAY,GAAG,WAAW;AACxB,SAAM,SAAS;AACf,UAAO;KAEV;;CAGH,QAAQ,YAAwB,WAA4B;AAC1D,OAAK,MAAM,SAAS,KAAK,SAAS;GAChC,MAAM,WAAW,MAAM,YAAY,KAAK,MAAM,KAAK,kBAAkB,GAAG,UAAU,CAAC;AAInF,OAHiB,MAAM,OAAO,WAAW,KACpC,MAAM,OAAO,MAAM,MAAM,MAAM,WAAW,IAAI,CAGjD,MAAK,MAAM,MAAM,SAAU,YAAW,IAAI,GAAG;OAE7C,MAAK,MAAM,eAAe,MAAM,QAAQ;AACtC,QAAI,gBAAgB,WAAW,IAAK;AAEpC,QAAI,KAAK,iBAAiB,YAAY,EAAE;KACtC,MAAM,gBAAgB,UAAU,IAAgB,YAAY,aAAa,EAAE,QAAQ,OAAO,CAAC;AAC3F,SAAI,cACF,MAAK,MAAM,MAAM,SAAU,eAAc,IAAI,GAAG;WAE7C;KACL,MAAM,QAAQ,KAAK,WAAW,YAA4B;AAC1D,gBAAW,WAAW,CAAC,MAAM,OAAO,SAAS;;;;;CAOvD,iBAAyB,OAAyC;AAChE,SACE,OAAO,UAAU,cACd,iBAAiB,SACjB,OAAQ,MAAkC,gBAAgB;;CAIjE,sBAA8B,GAA0E;AACtG,SAAO,OAAO,MAAM,cAAc,EAAE,cAAc,KAAA,KAAa,SAAS,EAAE;;CAG5E,kBAA0B,GAA4C,WAAqC;AACzG,MAAI,KAAK,sBAAsB,EAAE,EAAE;GACjC,MAAM,WAAW,UAAU,IAAuB,GAAG,EAAE,QAAQ,OAAO,CAAC;AACvE,UAAO,OAAO,KAAK,SAAS;AAC1B,UAAM,SAAS,IAAI,KAAK,KAAK;;;AAGjC,SAAO;;CAGT,WAAmB,MAA8B;EAC/C,MAAM,SAAqB,EAAE;AAC7B,MAAI,KAAK,MAAM;GACb,MAAM,OAAO,KAAK;AAClB,UAAO,MAAM,QAAQ,IAAI,QAAQ,IAAI,SAAS,KAAK;;AAErD,MAAI,KAAK,QAAQ;GACf,MAAM,SAAS,KAAK,OAAO,aAAa;AACxC,UAAO,MAAM,QAAQ,IAAI,QAAQ,OAAO,aAAa,KAAK,OAAO;;AAEnE,MAAI,KAAK,UAAU;GACjB,MAAM,WAAA,GAAA,UAAA,SAA+C,KAAK,SAAS;AACnE,UAAO,MAAM,QAAQ,QAAQ,IAAI,QAAQ,IAAI,SAAS,CAAC;;AAEzD,MAAI,OAAO,WAAW,EAAG,QAAO,OAAO;AACvC,UAAA,GAAA,IAAA,cAAoB,OAAO;;;;;ACzF/B,SAAgB,0BAA0B,UAAoD;AAC5F,QACE,aAAa,QACV,aAAa,KAAA,KACb,OAAQ,SAAqC,2BAA2B;;;;;;;;;;;;;;;;;;ACKxE,IAAA,YAAA,MAAM,UAAkC;CAC7C,YACE,kBACA,WACA,YACA;AAHiB,OAAA,mBAAA;AACA,OAAA,YAAA;AACA,OAAA,aAAA;;CAGnB,eAAqB;AACnB,OAAK,MAAM,GAAG,kBAAkB,KAAK,kBAAkB;GACrD,MAAM,WAAW,cAAc;AAC/B,OAAI,0BAA0B,SAAS,EAAE;IACvC,MAAM,WAAW,IAAI,2BAA2B;AAChD,aAAS,uBAAuB,SAAS;AACzC,aAAS,QAAQ,KAAK,YAAY,KAAK,UAAU;;;;;;6BAlBhD;4BACD;EACN,WAAW,CAAC;GAAE,SAASA,IAAAA;GAAY,kBAAkB,IAAIA,IAAAA,YAAY;GAAE,CAAC;EACxE,SAAS,CAACA,IAAAA,WAAW;EACtB,CAAC"}

package/dist/index.mjs

@@ -1,7 +1,83 @@
-import { KeqRequest } from "keq";
-import { ConfigurableModuleBuilder, Global } from "@nestjs/common";
-//#region src/keq.module-definition.ts
-const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder().build();
+import { Global, Module } from "@nestjs/common";
+import { ModuleRef, ModulesContainer } from "@nestjs/core";
+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 {
+	entries = [];
+	apply(...middlewares) {
+		const entry = {
+			middlewares,
+			routes: []
+		};
+		this.entries.push(entry);
+		return { forRoutes: (...routes) => {
+			entry.routes = routes;
+			return this;
+		} };
+	}
+	applyTo(keqRequest, moduleRef) {
+		for (const entry of this.entries) {
+			const resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, moduleRef));
+			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 = moduleRef.get(routeTarget.KEQ_REQUEST, { strict: false });
+					if (targetRequest) for (const mw of resolved) targetRequest.use(mw);
+				} else {
+					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;
+	}
+	resolveMiddleware(m, moduleRef) {
+		if (this.isNestMiddlewareClass(m)) {
+			const instance = moduleRef.get(m, { strict: false });
+			return async (ctx, next) => {
+				await instance.use(ctx, next);
+			};
+		}
+		return m;
+	}
+	buildRoute(info) {
+		const routes = [];
+		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 = picomatch(info.pathname);
+			routes.push((ctx) => isMatch(ctx.request.url.pathname));
+		}
+		if (routes.length === 1) return routes[0];
+		return composeRoute(routes);
+	}
+};
+//#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);
+}
 //#endregion
 //#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
@@ -12,46 +88,40 @@ function __decorate(decorators, target, key, desc) {
 }
 //#endregion
 //#region src/keq.module.ts
-/**
-* Provider that creates and configures a KeqRequest instance
-* Applies any middlewares defined in the module options
-*/
-const requestProvider = {
-	provide: KeqRequest,
-	useFactory: (config) => {
-		const request = new KeqRequest();
-		if (config.middlewares) for (const middleware of config.middlewares) request.use(middleware);
-		return request;
-	},
-	inject: [MODULE_OPTIONS_TOKEN]
-};
-let KeqModule = class KeqModule extends ConfigurableModuleClass {
-	/**
-	* Register the module with synchronous options
-	* @param options - Configuration options including middlewares
-	* @returns DynamicModule with KeqRequest provider
-	*/
-	static register(options) {
-		const mo = super.register(options);
-		mo.providers.push(requestProvider);
-		mo.global = true;
-		return mo;
-	}
-	/**
-	* Register the module with asynchronous options
-	* Useful when you need to inject dependencies like ConfigService
-	* @param options - Async configuration options
-	* @returns DynamicModule with KeqRequest provider
-	*/
-	static registerAsync(options) {
-		const mo = super.registerAsync(options);
-		mo.providers.push(requestProvider);
-		mo.global = true;
-		return mo;
+var _ref, _ref2, _ref3;
+let KeqModule = class KeqModule {
+	constructor(modulesContainer, moduleRef, keqRequest) {
+		this.modulesContainer = modulesContainer;
+		this.moduleRef = moduleRef;
+		this.keqRequest = keqRequest;
+	}
+	onModuleInit() {
+		for (const [, moduleWrapper] of this.modulesContainer) {
+			const instance = moduleWrapper.instance;
+			if (hasConfigureKeqMiddleware(instance)) {
+				const consumer = new KeqMiddlewareConsumerImpl();
+				instance.configureKeqMiddleware(consumer);
+				consumer.applyTo(this.keqRequest, this.moduleRef);
+			}
+		}
 	}
 };
-KeqModule = __decorate([Global()], KeqModule);
+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 ModuleRef !== "undefined" && ModuleRef) === "function" ? _ref2 : Object,
+		typeof (_ref3 = typeof KeqRequest !== "undefined" && KeqRequest) === "function" ? _ref3 : Object
+	])
+], KeqModule);
 //#endregion
-export { KeqModule };
+export { KEQ_ROUTES, KeqModule };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/keq.module-definition.ts","../src/keq.module.ts"],"sourcesContent":["\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n","\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Global, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\n\n/**\n * Provider that creates and configures a KeqRequest instance\n * Applies any middlewares defined in the module options\n */\nconst requestProvider: Provider = {\n  provide: KeqRequest,\n  useFactory: (config: KeqModuleOptions) => {\n    const request = new KeqRequest()\n\n    if (config.middlewares) {\n      for (const middleware of config.middlewares) {\n        request.use(middleware)\n      }\n    }\n\n    return request\n  },\n  inject: [MODULE_OPTIONS_TOKEN],\n}\n\n/**\n * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS\n *\n * This module is global, so KeqRequest can be injected anywhere in your application\n * without needing to import the module in every feature module.\n *\n * @example\n * ```typescript\n * // Synchronous registration\n * KeqModule.register({\n *   middlewares: [...]\n * })\n *\n * // Asynchronous registration\n * KeqModule.registerAsync({\n *   imports: [ConfigModule],\n *   useFactory: (config: ConfigService) => ({\n *     middlewares: [...]\n *   }),\n *   inject: [ConfigService]\n * })\n *\n * // Inject in service\n * class UserService {\n *   constructor(private readonly keqRequest: KeqRequest) {}\n *   async getUser(id: string) {\n *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')\n *   }\n * }\n * ```\n */\n@Global()\nexport class KeqModule extends ConfigurableModuleClass {\n  /**\n   * Register the module with synchronous options\n   * @param options - Configuration options including middlewares\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n\n  /**\n   * Register the module with asynchronous options\n   * Useful when you need to inject dependencies like ConfigService\n   * @param options - Async configuration options\n   * @returns DynamicModule with KeqRequest provider\n   */\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n    mo.global = true\n\n    return mo\n  }\n}\n"],"mappings":";;;AAKA,MAAa,EACX,yBACA,sBACA,cACA,uBACE,IAAI,2BAA6C,CAAC,OAAO;;;;;;;;;;;;;;;ACC7D,MAAM,kBAA4B;CAChC,SAAS;CACT,aAAa,WAA6B;EACxC,MAAM,UAAU,IAAI,YAAY;AAEhC,MAAI,OAAO,YACT,MAAK,MAAM,cAAc,OAAO,YAC9B,SAAQ,IAAI,WAAW;AAI3B,SAAO;;CAET,QAAQ,CAAC,qBAAqB;CAC/B;AAkCM,IAAA,YAAA,MAAM,kBAAkB,wBAAwB;;;;;;CAMrD,OAAO,SAAS,SAA6C;EAC3D,MAAM,KAAK,MAAM,SAAS,QAAQ;AAClC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;;;;;;CAST,OAAO,cAAc,SAAmD;EACtE,MAAM,KAAK,MAAM,cAAc,QAAQ;AACvC,KAAG,UAAW,KAAK,gBAAgB;AACnC,KAAG,SAAS;AAEZ,SAAO;;;wBA1BV,QAAQ,CAAA,EAAA,UAAA"}
+{"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 { ModuleRef } from '@nestjs/core'\nimport type { 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}\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    this.entries.push(entry)\n    return {\n      forRoutes: (...routes) => {\n        entry.routes = routes\n        return this\n      },\n    }\n  }\n\n  applyTo(keqRequest: KeqRequest, moduleRef: ModuleRef): void {\n    for (const entry of this.entries) {\n      const resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, moduleRef))\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 = moduleRef.get<KeqRequest>(routeTarget.KEQ_REQUEST, { strict: false })\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 resolveMiddleware(m: Type<KeqNestMiddleware> | KeqMiddleware, moduleRef: ModuleRef): KeqMiddleware {\n    if (this.isNestMiddlewareClass(m)) {\n      const instance = moduleRef.get<KeqNestMiddleware>(m, { strict: false })\n      return async (ctx, next) => {\n        await instance.use(ctx, next)\n      }\n    }\n    return m\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","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 } from '@nestjs/common'\nimport { ModulesContainer, ModuleRef } 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@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 moduleRef: ModuleRef,\n    private readonly keqRequest: KeqRequest,\n  ) {}\n\n  onModuleInit(): void {\n    for (const [, moduleWrapper] of this.modulesContainer) {\n      const instance = moduleWrapper.instance\n      if (hasConfigureKeqMiddleware(instance)) {\n        const consumer = new KeqMiddlewareConsumerImpl()\n        instance.configureKeqMiddleware(consumer)\n        consumer.applyTo(this.keqRequest, this.moduleRef)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;AAAA,MAAa,aAAa,EACxB,KAAK,OAAO,iBAAiB,EAC9B;;;ACaD,IAAa,4BAAb,MAAwE;CACtE,UAAqC,EAAE;CAEvC,MAAM,GAAG,aAAuF;EAC9F,MAAM,QAAyB;GAAE;GAAa,QAAQ,EAAE;GAAE;AAC1D,OAAK,QAAQ,KAAK,MAAM;AACxB,SAAO,EACL,YAAY,GAAG,WAAW;AACxB,SAAM,SAAS;AACf,UAAO;KAEV;;CAGH,QAAQ,YAAwB,WAA4B;AAC1D,OAAK,MAAM,SAAS,KAAK,SAAS;GAChC,MAAM,WAAW,MAAM,YAAY,KAAK,MAAM,KAAK,kBAAkB,GAAG,UAAU,CAAC;AAInF,OAHiB,MAAM,OAAO,WAAW,KACpC,MAAM,OAAO,MAAM,MAAM,MAAM,WAAW,IAAI,CAGjD,MAAK,MAAM,MAAM,SAAU,YAAW,IAAI,GAAG;OAE7C,MAAK,MAAM,eAAe,MAAM,QAAQ;AACtC,QAAI,gBAAgB,WAAW,IAAK;AAEpC,QAAI,KAAK,iBAAiB,YAAY,EAAE;KACtC,MAAM,gBAAgB,UAAU,IAAgB,YAAY,aAAa,EAAE,QAAQ,OAAO,CAAC;AAC3F,SAAI,cACF,MAAK,MAAM,MAAM,SAAU,eAAc,IAAI,GAAG;WAE7C;KACL,MAAM,QAAQ,KAAK,WAAW,YAA4B;AAC1D,gBAAW,WAAW,CAAC,MAAM,OAAO,SAAS;;;;;CAOvD,iBAAyB,OAAyC;AAChE,SACE,OAAO,UAAU,cACd,iBAAiB,SACjB,OAAQ,MAAkC,gBAAgB;;CAIjE,sBAA8B,GAA0E;AACtG,SAAO,OAAO,MAAM,cAAc,EAAE,cAAc,KAAA,KAAa,SAAS,EAAE;;CAG5E,kBAA0B,GAA4C,WAAqC;AACzG,MAAI,KAAK,sBAAsB,EAAE,EAAE;GACjC,MAAM,WAAW,UAAU,IAAuB,GAAG,EAAE,QAAQ,OAAO,CAAC;AACvE,UAAO,OAAO,KAAK,SAAS;AAC1B,UAAM,SAAS,IAAI,KAAK,KAAK;;;AAGjC,SAAO;;CAGT,WAAmB,MAA8B;EAC/C,MAAM,SAAqB,EAAE;AAC7B,MAAI,KAAK,MAAM;GACb,MAAM,OAAO,KAAK;AAClB,UAAO,MAAM,QAAQ,IAAI,QAAQ,IAAI,SAAS,KAAK;;AAErD,MAAI,KAAK,QAAQ;GACf,MAAM,SAAS,KAAK,OAAO,aAAa;AACxC,UAAO,MAAM,QAAQ,IAAI,QAAQ,OAAO,aAAa,KAAK,OAAO;;AAEnE,MAAI,KAAK,UAAU;GACjB,MAAM,UAAqC,UAAU,KAAK,SAAS;AACnE,UAAO,MAAM,QAAQ,QAAQ,IAAI,QAAQ,IAAI,SAAS,CAAC;;AAEzD,MAAI,OAAO,WAAW,EAAG,QAAO,OAAO;AACvC,SAAO,aAAa,OAAO;;;;;ACzF/B,SAAgB,0BAA0B,UAAoD;AAC5F,QACE,aAAa,QACV,aAAa,KAAA,KACb,OAAQ,SAAqC,2BAA2B;;;;;;;;;;;;;;;;;;ACKxE,IAAA,YAAA,MAAM,UAAkC;CAC7C,YACE,kBACA,WACA,YACA;AAHiB,OAAA,mBAAA;AACA,OAAA,YAAA;AACA,OAAA,aAAA;;CAGnB,eAAqB;AACnB,OAAK,MAAM,GAAG,kBAAkB,KAAK,kBAAkB;GACrD,MAAM,WAAW,cAAc;AAC/B,OAAI,0BAA0B,SAAS,EAAE;IACvC,MAAM,WAAW,IAAI,2BAA2B;AAChD,aAAS,uBAAuB,SAAS;AACzC,aAAS,QAAQ,KAAK,YAAY,KAAK,UAAU;;;;;;CAlBxD,QAAQ;CACR,OAAO;EACN,WAAW,CAAC;GAAE,SAAS;GAAY,kBAAkB,IAAI,YAAY;GAAE,CAAC;EACxE,SAAS,CAAC,WAAW;EACtB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keq-request/nestjs",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.10",
   "description": "Request API write by Typescript for flexibility, readability, and a low learning curve.",
   "keywords": [
     "request",
@@ -33,14 +33,20 @@
     "type": "git",
     "url": "git+https://github.com/keq-request/keq.git"
   },
+  "dependencies": {
+    "picomatch": "^4.0.0"
+  },
   "devDependencies": {
     "@nestjs/common": "^11.1.19",
+    "@nestjs/core": "^11.1.19",
     "@types/node": "^20.19.39",
-    "keq": "5.0.0-beta.1"
+    "@types/picomatch": "^4.0.0",
+    "keq": "5.0.0-beta.10"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0",
-    "keq": "^5.0.0-beta.1"
+    "@nestjs/core": "^11.0.0",
+    "keq": "^5.0.0-beta.10"
   },
   "engines": {
     "node": ">=20.0.0"

package/src/constants.ts

@@ -0,0 +1,3 @@
+export const KEQ_ROUTES = {
+  ALL: Symbol('KEQ_ROUTES.ALL'),
+} as const

package/src/index.ts

@@ -1,2 +1,3 @@
 export * from './keq.module.js'
-export * from './types/index.js'
+export * from './constants.js'
+export * from './interfaces/index.js'

package/src/interfaces/index.ts

@@ -0,0 +1,4 @@
+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 { KeqModuleOptions } from './keq-module-options.interface.js'

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

@@ -0,0 +1,23 @@
+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'
+
+
+export interface KeqRouteInfo {
+  host?: string
+  method?: string
+  pathname?: string
+}
+
+export interface KeqModuleClass {
+  readonly KEQ_REQUEST: symbol
+}
+
+export interface KeqMiddlewareConfigProxy {
+  forRoutes(...routes: Array<typeof KEQ_ROUTES.ALL | KeqRouteInfo | KeqModuleClass>): KeqMiddlewareConsumer
+}
+
+export interface KeqMiddlewareConsumer {
+  apply(...middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>): KeqMiddlewareConfigProxy
+}

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

@@ -0,0 +1,6 @@
+import type { KeqMiddlewareConsumer } from './keq-middleware-consumer.interface.js'
+
+
+export interface KeqMiddlewareModule {
+  configureKeqMiddleware(consumer: KeqMiddlewareConsumer): void
+}

package/src/{types/keq-module-options.ts → interfaces/keq-module-options.interface.ts}

@@ -1,6 +1,7 @@
-import { KeqMiddleware } from 'keq'
+import type { KeqMiddleware } from 'keq'
 
 
 export interface KeqModuleOptions {
   middlewares?: KeqMiddleware[]
+  isolate?: boolean
 }

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

@@ -0,0 +1,6 @@
+import type { KeqExecutionContext, KeqNext } from 'keq'
+
+
+export interface KeqNestMiddleware {
+  use(ctx: KeqExecutionContext, next: KeqNext): void | PromiseLike<void>
+}

package/src/keq-middleware-consumer.ts

@@ -0,0 +1,95 @@
+import type { Type } from '@nestjs/common'
+import type { ModuleRef } from '@nestjs/core'
+import type { KeqMiddleware, KeqRoute } from 'keq'
+import { composeRoute, KeqRequest } from 'keq'
+import picomatch from 'picomatch'
+import { KEQ_ROUTES } from './constants.js'
+import type { KeqMiddlewareConfigProxy, KeqMiddlewareConsumer, KeqModuleClass, KeqRouteInfo } from './interfaces/keq-middleware-consumer.interface.js'
+import type { KeqNestMiddleware } from './interfaces/keq-nest-middleware.interface.js'
+
+
+interface MiddlewareEntry {
+  middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>
+  routes: Array<typeof KEQ_ROUTES.ALL | KeqRouteInfo | KeqModuleClass>
+}
+
+export class KeqMiddlewareConsumerImpl implements KeqMiddlewareConsumer {
+  private entries: MiddlewareEntry[] = []
+
+  apply(...middlewares: Array<Type<KeqNestMiddleware> | KeqMiddleware>): KeqMiddlewareConfigProxy {
+    const entry: MiddlewareEntry = { middlewares, routes: [] }
+    this.entries.push(entry)
+    return {
+      forRoutes: (...routes) => {
+        entry.routes = routes
+        return this
+      },
+    }
+  }
+
+  applyTo(keqRequest: KeqRequest, moduleRef: ModuleRef): void {
+    for (const entry of this.entries) {
+      const resolved = entry.middlewares.map((m) => this.resolveMiddleware(m, moduleRef))
+      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
+
+          if (this.isKeqModuleClass(routeTarget)) {
+            const targetRequest = moduleRef.get<KeqRequest>(routeTarget.KEQ_REQUEST, { strict: false })
+            if (targetRequest) {
+              for (const mw of resolved) targetRequest.use(mw)
+            }
+          } else {
+            const route = this.buildRoute(routeTarget as KeqRouteInfo)
+            keqRequest.useRouter().route(route, resolved)
+          }
+        }
+      }
+    }
+  }
+
+  private isKeqModuleClass(route: unknown): route is KeqModuleClass {
+    return (
+      typeof route === 'function'
+      && 'KEQ_REQUEST' in route
+      && typeof (route as Record<string, unknown>).KEQ_REQUEST === 'symbol'
+    )
+  }
+
+  private isNestMiddlewareClass(m: Type<KeqNestMiddleware> | KeqMiddleware): m is Type<KeqNestMiddleware> {
+    return typeof m === 'function' && m.prototype !== undefined && 'use' in m.prototype
+  }
+
+  private resolveMiddleware(m: Type<KeqNestMiddleware> | KeqMiddleware, moduleRef: ModuleRef): KeqMiddleware {
+    if (this.isNestMiddlewareClass(m)) {
+      const instance = moduleRef.get<KeqNestMiddleware>(m, { strict: false })
+      return async (ctx, next) => {
+        await instance.use(ctx, next)
+      }
+    }
+    return 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)
+  }
+}

package/src/keq.module.ts

@@ -1,87 +1,30 @@
-
+import { Global, Module, OnModuleInit } from '@nestjs/common'
+import { ModulesContainer, ModuleRef } from '@nestjs/core'
 import { KeqRequest } from 'keq'
-import { DynamicModule, Global, Provider } from '@nestjs/common'
-import { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'
-import { KeqModuleOptions } from './types/index.js'
-
+import { KeqMiddlewareConsumerImpl } from './keq-middleware-consumer.js'
+import { hasConfigureKeqMiddleware } from './utils/has-configure-keq-middleware.js'
 
-/**
- * Provider that creates and configures a KeqRequest instance
- * Applies any middlewares defined in the module options
- */
-const requestProvider: Provider = {
-  provide: KeqRequest,
-  useFactory: (config: KeqModuleOptions) => {
-    const request = new KeqRequest()
 
-    if (config.middlewares) {
-      for (const middleware of config.middlewares) {
-        request.use(middleware)
+@Global()
+@Module({
+  providers: [{ provide: KeqRequest, useFactory: () => new KeqRequest() }],
+  exports: [KeqRequest],
+})
+export class KeqModule implements OnModuleInit {
+  constructor(
+    private readonly modulesContainer: ModulesContainer,
+    private readonly moduleRef: ModuleRef,
+    private readonly keqRequest: KeqRequest,
+  ) {}
+
+  onModuleInit(): void {
+    for (const [, moduleWrapper] of this.modulesContainer) {
+      const instance = moduleWrapper.instance
+      if (hasConfigureKeqMiddleware(instance)) {
+        const consumer = new KeqMiddlewareConsumerImpl()
+        instance.configureKeqMiddleware(consumer)
+        consumer.applyTo(this.keqRequest, this.moduleRef)
       }
     }
-
-    return request
-  },
-  inject: [MODULE_OPTIONS_TOKEN],
-}
-
-/**
- * KeqModule - Dynamic module for integrating Keq HTTP client with NestJS
- *
- * This module is global, so KeqRequest can be injected anywhere in your application
- * without needing to import the module in every feature module.
- *
- * @example
- * ```typescript
- * // Synchronous registration
- * KeqModule.register({
- *   middlewares: [...]
- * })
- *
- * // Asynchronous registration
- * KeqModule.registerAsync({
- *   imports: [ConfigModule],
- *   useFactory: (config: ConfigService) => ({
- *     middlewares: [...]
- *   }),
- *   inject: [ConfigService]
- * })
- *
- * // Inject in service
- * class UserService {
- *   constructor(private readonly keqRequest: KeqRequest) {}
- *   async getUser(id: string) {
- *     return await this.keqRequest.get(`/users/${id}`).resolveWith('json')
- *   }
- * }
- * ```
- */
-@Global()
-export class KeqModule extends ConfigurableModuleClass {
-  /**
-   * Register the module with synchronous options
-   * @param options - Configuration options including middlewares
-   * @returns DynamicModule with KeqRequest provider
-   */
-  static register(options: typeof OPTIONS_TYPE): DynamicModule {
-    const mo = super.register(options)
-    mo.providers!.push(requestProvider)
-    mo.global = true
-
-    return mo
-  }
-
-  /**
-   * Register the module with asynchronous options
-   * Useful when you need to inject dependencies like ConfigService
-   * @param options - Async configuration options
-   * @returns DynamicModule with KeqRequest provider
-   */
-  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
-    const mo = super.registerAsync(options)
-    mo.providers!.push(requestProvider)
-    mo.global = true
-
-    return mo
   }
 }

package/src/utils/has-configure-keq-middleware.ts

@@ -0,0 +1,10 @@
+import type { KeqMiddlewareModule } from '../interfaces/keq-middleware-module.interface.js'
+
+
+export function hasConfigureKeqMiddleware(instance: unknown): instance is KeqMiddlewareModule {
+  return (
+    instance !== null
+    && instance !== undefined
+    && typeof (instance as Record<string, unknown>).configureKeqMiddleware === 'function'
+  )
+}

package/src/keq.module-definition.ts

@@ -1,11 +0,0 @@
-
-import { ConfigurableModuleBuilder } from '@nestjs/common'
-import { KeqModuleOptions } from './types/keq-module-options'
-
-
-export const {
-  ConfigurableModuleClass,
-  MODULE_OPTIONS_TOKEN,
-  OPTIONS_TYPE,
-  ASYNC_OPTIONS_TYPE,
-} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()

package/src/types/index.ts

@@ -1 +0,0 @@
-export * from './keq-module-options.js'