@keq-request/nestjs 5.0.0-alpha.30 → 5.0.0-alpha.32

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @keq-request/nestjs@5.0.0-alpha.30 build /home/runner/work/keq/keq/packages/nestjs
+> @keq-request/nestjs@5.0.0-alpha.32 build /home/runner/work/keq/keq/packages/nestjs
 > tsup
 
 CLI Building entry: src/index.ts
@@ -10,9 +10,9 @@
 CLI Cleaning output folder
 CJS Build start
 ESM Build start
-CJS dist/index.js     2.17 KB
-CJS dist/index.js.map 2.55 KB
-CJS ⚡️ Build success in 83ms
-ESM dist/index.mjs     1.19 KB
-ESM dist/index.mjs.map 2.46 KB
-ESM ⚡️ Build success in 84ms
+CJS dist/index.js     3.28 KB
+CJS dist/index.js.map 4.04 KB
+CJS ⚡️ Build success in 89ms
+ESM dist/index.mjs     2.27 KB
+ESM dist/index.mjs.map 3.94 KB
+ESM ⚡️ Build success in 96ms

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @keq-request/nestjs
 
+## 5.0.0-alpha.32
+
+### Patch Changes
+
+- Updated dependencies [f194c41]
+- Updated dependencies [b8d02ca]
+  - keq@5.0.0-alpha.32
+
+## 5.0.0-alpha.31
+
+### Patch Changes
+
+- keq@5.0.0-alpha.31
+
 ## 5.0.0-alpha.30
 
 ### Patch Changes

package/dist/index.js

@@ -27,12 +27,20 @@ module.exports = __toCommonJS(index_exports);
 
 // src/keq.module.ts
 var import_keq = require("keq");
+var import_common2 = require("@nestjs/common");
 
 // src/keq.module-definition.ts
 var import_common = require("@nestjs/common");
-var { ConfigurableModuleClass: KeqModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new import_common.ConfigurableModuleBuilder().build();
+var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new import_common.ConfigurableModuleBuilder().build();
 
 // src/keq.module.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
 var requestProvider = {
   provide: import_keq.KeqRequest,
   useFactory: /* @__PURE__ */ __name((config) => {
@@ -48,21 +56,37 @@ var requestProvider = {
     MODULE_OPTIONS_TOKEN
   ]
 };
-var KeqModule = class extends KeqModuleClass {
+var KeqModule = class extends ConfigurableModuleClass {
   static {
     __name(this, "KeqModule");
   }
+  /**
+  * 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;
   }
 };
+KeqModule = _ts_decorate([
+  (0, import_common2.Global)()
+], KeqModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeqModule

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/keq.module.ts","../src/keq.module-definition.ts"],"sourcesContent":["export * from './keq.module.js'\nexport * from './types/index.js'\n","/* eslint-disable @typescript-eslint/no-unsafe-return */\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, KeqModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\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\nexport class KeqModule extends KeqModuleClass {\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n\n    return mo\n  }\n\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n\n    return mo\n  }\n}\n","\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass: KeqModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;ACCA,iBAA2B;;;ACA3B,oBAA0C;AAInC,IAAM,EACXA,yBAAyBC,gBACzBC,sBACAC,cACAC,mBAAkB,IAChB,IAAIC,wCAAAA,EAA8CC,MAAK;;;ADH3D,IAAMC,kBAA4B;EAChCC,SAASC;EACTC,YAAY,wBAACC,WAAAA;AACX,UAAMC,UAAU,IAAIH,sBAAAA;AAEpB,QAAIE,OAAOE,aAAa;AACtB,iBAAWC,cAAcH,OAAOE,aAAa;AAC3CD,gBAAQG,IAAID,UAAAA;MACd;IACF;AAEA,WAAOF;EACT,GAVY;EAWZI,QAAQ;IAACC;;AACX;AAEO,IAAMC,YAAN,cAAwBC,eAAAA;EAvB/B,OAuB+BA;;;EAC7B,OAAOC,SAASC,SAA6C;AAC3D,UAAMC,KAAK,MAAMF,SAASC,OAAAA;AAC1BC,OAAGC,UAAWC,KAAKjB,eAAAA;AAEnB,WAAOe;EACT;EAEA,OAAOG,cAAcJ,SAAmD;AACtE,UAAMC,KAAK,MAAMG,cAAcJ,OAAAA;AAC/BC,OAAGC,UAAWC,KAAKjB,eAAAA;AAEnB,WAAOe;EACT;AACF;","names":["ConfigurableModuleClass","KeqModuleClass","MODULE_OPTIONS_TOKEN","OPTIONS_TYPE","ASYNC_OPTIONS_TYPE","ConfigurableModuleBuilder","build","requestProvider","provide","KeqRequest","useFactory","config","request","middlewares","middleware","use","inject","MODULE_OPTIONS_TOKEN","KeqModule","KeqModuleClass","register","options","mo","providers","push","registerAsync"]}
+{"version":3,"sources":["../src/index.ts","../src/keq.module.ts","../src/keq.module-definition.ts"],"sourcesContent":["export * from './keq.module.js'\nexport * from './types/index.js'\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","\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"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;ACCA,iBAA2B;AAC3B,IAAAA,iBAAgD;;;ACDhD,oBAA0C;AAInC,IAAM,EACXC,yBACAC,sBACAC,cACAC,mBAAkB,IAChB,IAAIC,wCAAAA,EAA8CC,MAAK;;;;;;;;;;ADC3D,IAAMC,kBAA4B;EAChCC,SAASC;EACTC,YAAY,wBAACC,WAAAA;AACX,UAAMC,UAAU,IAAIH,sBAAAA;AAEpB,QAAIE,OAAOE,aAAa;AACtB,iBAAWC,cAAcH,OAAOE,aAAa;AAC3CD,gBAAQG,IAAID,UAAAA;MACd;IACF;AAEA,WAAOF;EACT,GAVY;EAWZI,QAAQ;IAACC;;AACX;AAkCO,IAAMC,YAAN,cAAwBC,wBAAAA;SAAAA;;;;;;;;EAM7B,OAAOC,SAASC,SAA6C;AAC3D,UAAMC,KAAK,MAAMF,SAASC,OAAAA;AAC1BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;;;;;;;EAQA,OAAOI,cAAcL,SAAmD;AACtE,UAAMC,KAAK,MAAMI,cAAcL,OAAAA;AAC/BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;AACF;AA3BaJ,YAAAA,aAAAA;MADZS,uBAAAA;GACYT,SAAAA;","names":["import_common","ConfigurableModuleClass","MODULE_OPTIONS_TOKEN","OPTIONS_TYPE","ASYNC_OPTIONS_TYPE","ConfigurableModuleBuilder","build","requestProvider","provide","KeqRequest","useFactory","config","request","middlewares","middleware","use","inject","MODULE_OPTIONS_TOKEN","KeqModule","ConfigurableModuleClass","register","options","mo","providers","push","global","registerAsync","Global"]}

package/dist/index.mjs

@@ -3,12 +3,20 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/keq.module.ts
 import { KeqRequest } from "keq";
+import { Global } from "@nestjs/common";
 
 // src/keq.module-definition.ts
 import { ConfigurableModuleBuilder } from "@nestjs/common";
-var { ConfigurableModuleClass: KeqModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder().build();
+var { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE, ASYNC_OPTIONS_TYPE } = new ConfigurableModuleBuilder().build();
 
 // src/keq.module.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
 var requestProvider = {
   provide: KeqRequest,
   useFactory: /* @__PURE__ */ __name((config) => {
@@ -24,21 +32,37 @@ var requestProvider = {
     MODULE_OPTIONS_TOKEN
   ]
 };
-var KeqModule = class extends KeqModuleClass {
+var KeqModule = class extends ConfigurableModuleClass {
   static {
     __name(this, "KeqModule");
   }
+  /**
+  * 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;
   }
 };
+KeqModule = _ts_decorate([
+  Global()
+], KeqModule);
 export {
   KeqModule
 };

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/keq.module.ts","../src/keq.module-definition.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-return */\nimport { KeqRequest } from 'keq'\nimport { DynamicModule, Provider } from '@nestjs/common'\nimport { ASYNC_OPTIONS_TYPE, KeqModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'\nimport { KeqModuleOptions } from './types/index.js'\n\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\nexport class KeqModule extends KeqModuleClass {\n  static register(options: typeof OPTIONS_TYPE): DynamicModule {\n    const mo = super.register(options)\n    mo.providers!.push(requestProvider)\n\n    return mo\n  }\n\n  static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {\n    const mo = super.registerAsync(options)\n    mo.providers!.push(requestProvider)\n\n    return mo\n  }\n}\n","\nimport { ConfigurableModuleBuilder } from '@nestjs/common'\nimport { KeqModuleOptions } from './types/keq-module-options'\n\n\nexport const {\n  ConfigurableModuleClass: KeqModuleClass,\n  MODULE_OPTIONS_TOKEN,\n  OPTIONS_TYPE,\n  ASYNC_OPTIONS_TYPE,\n} = new ConfigurableModuleBuilder<KeqModuleOptions>().build()\n"],"mappings":";;;;AACA,SAASA,kBAAkB;;;ACA3B,SAASC,iCAAiC;AAInC,IAAM,EACXC,yBAAyBC,gBACzBC,sBACAC,cACAC,mBAAkB,IAChB,IAAIL,0BAAAA,EAA8CM,MAAK;;;ADH3D,IAAMC,kBAA4B;EAChCC,SAASC;EACTC,YAAY,wBAACC,WAAAA;AACX,UAAMC,UAAU,IAAIH,WAAAA;AAEpB,QAAIE,OAAOE,aAAa;AACtB,iBAAWC,cAAcH,OAAOE,aAAa;AAC3CD,gBAAQG,IAAID,UAAAA;MACd;IACF;AAEA,WAAOF;EACT,GAVY;EAWZI,QAAQ;IAACC;;AACX;AAEO,IAAMC,YAAN,cAAwBC,eAAAA;EAvB/B,OAuB+BA;;;EAC7B,OAAOC,SAASC,SAA6C;AAC3D,UAAMC,KAAK,MAAMF,SAASC,OAAAA;AAC1BC,OAAGC,UAAWC,KAAKjB,eAAAA;AAEnB,WAAOe;EACT;EAEA,OAAOG,cAAcJ,SAAmD;AACtE,UAAMC,KAAK,MAAMG,cAAcJ,OAAAA;AAC/BC,OAAGC,UAAWC,KAAKjB,eAAAA;AAEnB,WAAOe;EACT;AACF;","names":["KeqRequest","ConfigurableModuleBuilder","ConfigurableModuleClass","KeqModuleClass","MODULE_OPTIONS_TOKEN","OPTIONS_TYPE","ASYNC_OPTIONS_TYPE","build","requestProvider","provide","KeqRequest","useFactory","config","request","middlewares","middleware","use","inject","MODULE_OPTIONS_TOKEN","KeqModule","KeqModuleClass","register","options","mo","providers","push","registerAsync"]}
+{"version":3,"sources":["../src/keq.module.ts","../src/keq.module-definition.ts"],"sourcesContent":["\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","\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"],"mappings":";;;;AACA,SAASA,kBAAkB;AAC3B,SAAwBC,cAAwB;;;ACDhD,SAASC,iCAAiC;AAInC,IAAM,EACXC,yBACAC,sBACAC,cACAC,mBAAkB,IAChB,IAAIJ,0BAAAA,EAA8CK,MAAK;;;;;;;;;;ADC3D,IAAMC,kBAA4B;EAChCC,SAASC;EACTC,YAAY,wBAACC,WAAAA;AACX,UAAMC,UAAU,IAAIH,WAAAA;AAEpB,QAAIE,OAAOE,aAAa;AACtB,iBAAWC,cAAcH,OAAOE,aAAa;AAC3CD,gBAAQG,IAAID,UAAAA;MACd;IACF;AAEA,WAAOF;EACT,GAVY;EAWZI,QAAQ;IAACC;;AACX;AAkCO,IAAMC,YAAN,cAAwBC,wBAAAA;SAAAA;;;;;;;;EAM7B,OAAOC,SAASC,SAA6C;AAC3D,UAAMC,KAAK,MAAMF,SAASC,OAAAA;AAC1BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;;;;;;;EAQA,OAAOI,cAAcL,SAAmD;AACtE,UAAMC,KAAK,MAAMI,cAAcL,OAAAA;AAC/BC,OAAGC,UAAWC,KAAKjB,eAAAA;AACnBe,OAAGG,SAAS;AAEZ,WAAOH;EACT;AACF;AA3BaJ,YAAAA,aAAAA;EADZS,OAAAA;GACYT,SAAAA;","names":["KeqRequest","Global","ConfigurableModuleBuilder","ConfigurableModuleClass","MODULE_OPTIONS_TOKEN","OPTIONS_TYPE","ASYNC_OPTIONS_TYPE","build","requestProvider","provide","KeqRequest","useFactory","config","request","middlewares","middleware","use","inject","MODULE_OPTIONS_TOKEN","KeqModule","ConfigurableModuleClass","register","options","mo","providers","push","global","registerAsync","Global"]}

package/dist/keq.module-definition.d.ts

@@ -1,3 +1,3 @@
 import { KeqModuleOptions } from './types/keq-module-options';
-export declare const KeqModuleClass: import("@nestjs/common").ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
+export declare const ConfigurableModuleClass: import("@nestjs/common").ConfigurableModuleCls<KeqModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol, OPTIONS_TYPE: KeqModuleOptions & Partial<{}>, ASYNC_OPTIONS_TYPE: import("@nestjs/common").ConfigurableModuleAsyncOptions<KeqModuleOptions, "create"> & Partial<{}>;
 //# sourceMappingURL=keq.module-definition.d.ts.map

package/dist/keq.module-definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keq.module-definition.d.ts","sourceRoot":"","sources":["../src/keq.module-definition.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAG7D,eAAO,MACoB,cAAc,8FACvC,oBAAoB,mBACpB,YAAY,kCACZ,kBAAkB,mGACyC,CAAA"}
+{"version":3,"file":"keq.module-definition.d.ts","sourceRoot":"","sources":["../src/keq.module-definition.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAG7D,eAAO,MACL,uBAAuB,8FACvB,oBAAoB,mBACpB,YAAY,kCACZ,kBAAkB,mGACyC,CAAA"}

package/dist/keq.module.d.ts

@@ -1,7 +1,49 @@
 import { DynamicModule } from '@nestjs/common';
-import { ASYNC_OPTIONS_TYPE, KeqModuleClass, OPTIONS_TYPE } from './keq.module-definition.js';
-export declare class KeqModule extends KeqModuleClass {
+import { ASYNC_OPTIONS_TYPE, ConfigurableModuleClass, OPTIONS_TYPE } from './keq.module-definition.js';
+/**
+ * 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')
+ *   }
+ * }
+ * ```
+ */
+export 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;
 }
 //# sourceMappingURL=keq.module.d.ts.map

package/dist/keq.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keq.module.d.ts","sourceRoot":"","sources":["../src/keq.module.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAY,MAAM,gBAAgB,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAwB,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAoBnH,qBAAa,SAAU,SAAQ,cAAc;IAC3C,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,YAAY,GAAG,aAAa;IAO5D,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,kBAAkB,GAAG,aAAa;CAMxE"}
+{"version":3,"file":"keq.module.d.ts","sourceRoot":"","sources":["../src/keq.module.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAoB,MAAM,gBAAgB,CAAA;AAChE,OAAO,EAAE,kBAAkB,EAAE,uBAAuB,EAAwB,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAwB5H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBACa,SAAU,SAAQ,uBAAuB;IACpD;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,YAAY,GAAG,aAAa;IAQ5D;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,OAAO,kBAAkB,GAAG,aAAa;CAOxE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keq-request/nestjs",
-  "version": "5.0.0-alpha.30",
+  "version": "5.0.0-alpha.32",
   "description": "Request API write by Typescript for flexibility, readability, and a low learning curve.",
   "keywords": [
     "request",
@@ -37,10 +37,10 @@
   "devDependencies": {
     "@types/node": "^20.19.25",
     "@nestjs/common": "^11.0.0",
-    "keq": "5.0.0-alpha.30"
+    "keq": "5.0.0-alpha.32"
   },
   "peerDependencies": {
-    "keq": "^5.0.0-alpha.30",
+    "keq": "^5.0.0-alpha.32",
     "@nestjs/common": "^11.0.0"
   },
   "engines": {

package/src/keq.module-definition.ts

@@ -4,7 +4,7 @@ import { KeqModuleOptions } from './types/keq-module-options'
 
 
 export const {
-  ConfigurableModuleClass: KeqModuleClass,
+  ConfigurableModuleClass,
   MODULE_OPTIONS_TOKEN,
   OPTIONS_TYPE,
   ASYNC_OPTIONS_TYPE,

package/src/keq.module.ts

@@ -1,10 +1,14 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+
 import { KeqRequest } from 'keq'
-import { DynamicModule, Provider } from '@nestjs/common'
-import { ASYNC_OPTIONS_TYPE, KeqModuleClass, MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './keq.module-definition.js'
+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'
 
 
+/**
+ * Provider that creates and configures a KeqRequest instance
+ * Applies any middlewares defined in the module options
+ */
 const requestProvider: Provider = {
   provide: KeqRequest,
   useFactory: (config: KeqModuleOptions) => {
@@ -21,17 +25,62 @@ const requestProvider: Provider = {
   inject: [MODULE_OPTIONS_TOKEN],
 }
 
-export class KeqModule extends KeqModuleClass {
+/**
+ * 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
   }