@mondart/nestjs-common-module 2.3.4 → 2.4.0

package/dist/decorators/swagger-api-response.decorator.d.ts

@@ -3,6 +3,7 @@ export declare function CustomApiResponse({ options, }: {
         status: number;
         description: string;
         responseDto: any;
+        metadata?: any;
         isArray?: boolean;
     };
 }): (target: any, key?: string, descriptor?: PropertyDescriptor) => void;

package/dist/decorators/swagger-api-response.decorator.js

@@ -27,6 +27,11 @@ function CustomApiResponse({ options, }) {
                     {
                         properties: {
                             data: dataSchema,
+                            metadata: options.metadata
+                                ? {
+                                    $ref: (0, swagger_1.getSchemaPath)(options.metadata),
+                                }
+                                : undefined,
                         },
                     },
                 ],

package/dist/dto/request/base-request.dto.js

@@ -21,3 +21,8 @@ __decorate([
     (0, class_validator_1.IsOptional)(),
     __metadata("design:type", Boolean)
 ], BaseRequest.prototype, "isActive", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: {} }),
+    (0, class_validator_1.IsOptional)(),
+    __metadata("design:type", Object)
+], BaseRequest.prototype, "metadata", void 0);

package/dist/dto/response/index.d.ts

@@ -6,3 +6,4 @@ export * from './validation.dto';
 export * from './kafka-success-response.dto';
 export * from './kafka-failed-response.dto';
 export * from './iam-context.dto';
+export * from './paginate-metadata-response.dto';

package/dist/dto/response/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./validation.dto"), exports);
 __exportStar(require("./kafka-success-response.dto"), exports);
 __exportStar(require("./kafka-failed-response.dto"), exports);
 __exportStar(require("./iam-context.dto"), exports);
+__exportStar(require("./paginate-metadata-response.dto"), exports);

package/dist/dto/response/paginate-metadata-response.dto.d.ts

@@ -0,0 +1,12 @@
+import { PaginatedMetaDocumented } from 'nestjs-paginate';
+declare class PaginatedMetadataLinksDocumented {
+    first?: string;
+    previous?: string;
+    current: string;
+    next?: string;
+    last?: string;
+}
+export declare class PaginateMetadataResponseDto extends PaginatedMetaDocumented<any> {
+    links: PaginatedMetadataLinksDocumented;
+}
+export {};

package/dist/dto/response/paginate-metadata-response.dto.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginateMetadataResponseDto = void 0;
+const nestjs_paginate_1 = require("nestjs-paginate");
+const swagger_1 = require("@nestjs/swagger");
+class PaginatedMetadataLinksDocumented {
+}
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: String }),
+    __metadata("design:type", String)
+], PaginatedMetadataLinksDocumented.prototype, "first", void 0);
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: String }),
+    __metadata("design:type", String)
+], PaginatedMetadataLinksDocumented.prototype, "previous", void 0);
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: String }),
+    __metadata("design:type", String)
+], PaginatedMetadataLinksDocumented.prototype, "current", void 0);
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: String }),
+    __metadata("design:type", String)
+], PaginatedMetadataLinksDocumented.prototype, "next", void 0);
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: String }),
+    __metadata("design:type", String)
+], PaginatedMetadataLinksDocumented.prototype, "last", void 0);
+class PaginateMetadataResponseDto extends nestjs_paginate_1.PaginatedMetaDocumented {
+}
+exports.PaginateMetadataResponseDto = PaginateMetadataResponseDto;
+__decorate([
+    (0, swagger_1.ApiResponseProperty)({ type: PaginatedMetadataLinksDocumented }),
+    __metadata("design:type", PaginatedMetadataLinksDocumented)
+], PaginateMetadataResponseDto.prototype, "links", void 0);

package/dist/dto/response/success-response.dto.d.ts

@@ -1,9 +1,9 @@
-export declare class BaseSuccessResponse<type> {
-    data: type;
-    metadata: object;
+export declare class BaseSuccessResponse<dataType, metaType = any> {
+    data: dataType;
+    metadata: metaType;
     message: string;
     status: number;
 }
-export declare class SuccessResponse<type> extends BaseSuccessResponse<type> {
-    constructor(data: type, message?: string, status?: number, metadata?: any);
+export declare class SuccessResponse<dataType, metaType = any> extends BaseSuccessResponse<dataType, metaType> {
+    constructor(data: dataType, message?: string, status?: number, metadata?: metaType);
 }

package/dist/lib/bottleneck/bottleneck.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { BottleneckModuleAsyncOptions, BottleneckModuleOptions } from './interfaces/bottleneck-options.interface';
+export declare class BottleneckModule {
+    static register(options: BottleneckModuleOptions): DynamicModule;
+    static registerAsync(options: BottleneckModuleAsyncOptions): DynamicModule;
+    private static createAsyncOptionsProvider;
+    private static createAsyncProviders;
+}

package/dist/lib/bottleneck/bottleneck.module.js

@@ -0,0 +1,109 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var BottleneckModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BottleneckModule = void 0;
+const common_1 = require("@nestjs/common");
+const bottleneck_service_1 = require("./services/bottleneck.service");
+const bottleneck_options_interface_1 = require("./interfaces/bottleneck-options.interface");
+const bottleneck_interceptor_1 = require("./interceptors/bottleneck.interceptor");
+const core_1 = require("@nestjs/core");
+const queued_command_bus_1 = require("./cqrs-wrapper/queued-command-bus");
+const queued_query_bus_1 = require("./cqrs-wrapper/queued-query-bus");
+const cqrs_1 = require("@nestjs/cqrs");
+let BottleneckModule = BottleneckModule_1 = class BottleneckModule {
+    static register(options) {
+        return {
+            module: BottleneckModule_1,
+            imports: [cqrs_1.CqrsModule],
+            providers: [
+                bottleneck_service_1.BottleneckService,
+                queued_command_bus_1.QueuedCommandBus,
+                queued_query_bus_1.QueuedQueryBus,
+                {
+                    provide: core_1.APP_INTERCEPTOR,
+                    useClass: bottleneck_interceptor_1.BottleneckInterceptor,
+                },
+                {
+                    provide: bottleneck_options_interface_1.BOTTLENECK_MODULE_OPTIONS,
+                    useValue: options,
+                },
+            ],
+            controllers: [],
+            exports: [],
+        };
+    }
+    static registerAsync(options) {
+        const asyncOptionsProvider = this.createAsyncOptionsProvider(options);
+        return {
+            module: BottleneckModule_1,
+            imports: [...(options.imports || []), asyncOptionsProvider],
+            providers: [],
+            controllers: [],
+            exports: [],
+        };
+    }
+    static createAsyncOptionsProvider(options) {
+        const providers = this.createAsyncProviders(options);
+        return {
+            module: BottleneckModule_1,
+            imports: [cqrs_1.CqrsModule],
+            providers,
+            exports: [bottleneck_options_interface_1.BOTTLENECK_MODULE_OPTIONS, queued_command_bus_1.QueuedCommandBus, queued_query_bus_1.QueuedQueryBus],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useFactory) {
+            return [
+                bottleneck_service_1.BottleneckService,
+                queued_command_bus_1.QueuedCommandBus,
+                queued_query_bus_1.QueuedQueryBus,
+                {
+                    provide: core_1.APP_INTERCEPTOR,
+                    useClass: bottleneck_interceptor_1.BottleneckInterceptor,
+                },
+                {
+                    provide: bottleneck_options_interface_1.BOTTLENECK_MODULE_OPTIONS,
+                    useFactory: options.useFactory,
+                    inject: options.inject || [],
+                },
+            ];
+        }
+        const useClass = options.useClass || options.useExisting;
+        if (useClass) {
+            return [
+                bottleneck_service_1.BottleneckService,
+                queued_command_bus_1.QueuedCommandBus,
+                queued_query_bus_1.QueuedQueryBus,
+                {
+                    provide: bottleneck_options_interface_1.BOTTLENECK_MODULE_OPTIONS,
+                    useFactory: async (optionsFactory) => await optionsFactory.createModuleOptions(),
+                    inject: [options.useExisting || options.useClass],
+                },
+                {
+                    provide: core_1.APP_INTERCEPTOR,
+                    useClass: bottleneck_interceptor_1.BottleneckInterceptor,
+                },
+                ...(options.useClass
+                    ? [
+                        {
+                            provide: options.useClass,
+                            useClass: options.useClass,
+                        },
+                    ]
+                    : []),
+            ];
+        }
+        throw new Error('Invalid BottleneckModuleAsyncOptions');
+    }
+};
+exports.BottleneckModule = BottleneckModule;
+exports.BottleneckModule = BottleneckModule = BottleneckModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], BottleneckModule);

package/dist/lib/bottleneck/constants/bottleneck.const.d.ts

@@ -0,0 +1,3 @@
+export declare const SKIP_CART_BOTTLENECK_KEY = "skipCartBottleneck";
+export declare const USE_CART_BOTTLENECK_KEY = "useCartBottleneck";
+export declare const CONFIG_CART_BOTTLENECK_KEY = "configCartBottleneck";

package/dist/lib/bottleneck/constants/bottleneck.const.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_CART_BOTTLENECK_KEY = exports.USE_CART_BOTTLENECK_KEY = exports.SKIP_CART_BOTTLENECK_KEY = void 0;
+exports.SKIP_CART_BOTTLENECK_KEY = 'skipCartBottleneck';
+exports.USE_CART_BOTTLENECK_KEY = 'useCartBottleneck';
+exports.CONFIG_CART_BOTTLENECK_KEY = 'configCartBottleneck';

package/dist/lib/bottleneck/cqrs-wrapper/queued-command-bus.d.ts

@@ -0,0 +1,8 @@
+import { CommandBus } from '@nestjs/cqrs';
+import { BottleneckService } from '../services/bottleneck.service';
+export declare class QueuedCommandBus {
+    private readonly commandBus;
+    private readonly bottleneckService;
+    constructor(commandBus: CommandBus, bottleneckService: BottleneckService);
+    execute<TCommand, TResult = any>(command: TCommand): Promise<TResult>;
+}

package/dist/lib/bottleneck/cqrs-wrapper/queued-command-bus.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueuedCommandBus = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+const bottleneck_service_1 = require("../services/bottleneck.service");
+let QueuedCommandBus = class QueuedCommandBus {
+    constructor(commandBus, bottleneckService) {
+        this.commandBus = commandBus;
+        this.bottleneckService = bottleneckService;
+    }
+    async execute(command) {
+        const key = `${command.constructor.name}:${JSON.stringify(command)}`;
+        return this.bottleneckService.runQueuedTask(key, async () => this.commandBus.execute(command));
+    }
+};
+exports.QueuedCommandBus = QueuedCommandBus;
+exports.QueuedCommandBus = QueuedCommandBus = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [cqrs_1.CommandBus,
+        bottleneck_service_1.BottleneckService])
+], QueuedCommandBus);

package/dist/lib/bottleneck/cqrs-wrapper/queued-query-bus.d.ts

@@ -0,0 +1,8 @@
+import { QueryBus } from '@nestjs/cqrs';
+import { BottleneckService } from '../services/bottleneck.service';
+export declare class QueuedQueryBus {
+    private readonly queryBus;
+    private readonly bottleneckService;
+    constructor(queryBus: QueryBus, bottleneckService: BottleneckService);
+    execute<TCommand, TResult = any>(command: TCommand): Promise<TResult>;
+}

package/dist/lib/bottleneck/cqrs-wrapper/queued-query-bus.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueuedQueryBus = void 0;
+const common_1 = require("@nestjs/common");
+const cqrs_1 = require("@nestjs/cqrs");
+const bottleneck_service_1 = require("../services/bottleneck.service");
+let QueuedQueryBus = class QueuedQueryBus {
+    constructor(queryBus, bottleneckService) {
+        this.queryBus = queryBus;
+        this.bottleneckService = bottleneckService;
+    }
+    async execute(command) {
+        const key = `${command.constructor.name}:${JSON.stringify(command)}`;
+        return this.bottleneckService.runQueuedTask(key, async () => this.queryBus.execute(command));
+    }
+};
+exports.QueuedQueryBus = QueuedQueryBus;
+exports.QueuedQueryBus = QueuedQueryBus = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [cqrs_1.QueryBus,
+        bottleneck_service_1.BottleneckService])
+], QueuedQueryBus);

package/dist/lib/bottleneck/decorators/config-bottleneck.decorator.d.ts

@@ -0,0 +1,2 @@
+import { BottleneckModuleOptions } from '../interfaces/bottleneck-options.interface';
+export declare const ConfigBottleneckDecorator: (config?: BottleneckModuleOptions) => import("@nestjs/common").CustomDecorator<string>;

package/dist/lib/bottleneck/decorators/config-bottleneck.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigBottleneckDecorator = void 0;
+const common_1 = require("@nestjs/common");
+const bottleneck_const_1 = require("../constants/bottleneck.const");
+const ConfigBottleneckDecorator = (config) => (0, common_1.SetMetadata)(bottleneck_const_1.CONFIG_CART_BOTTLENECK_KEY, config);
+exports.ConfigBottleneckDecorator = ConfigBottleneckDecorator;

package/dist/lib/bottleneck/decorators/skip-bottleneck.decorator.d.ts

@@ -0,0 +1 @@
+export declare const SkipBottleneckDecorator: () => import("@nestjs/common").CustomDecorator<string>;

package/dist/lib/bottleneck/decorators/skip-bottleneck.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipBottleneckDecorator = void 0;
+const common_1 = require("@nestjs/common");
+const bottleneck_const_1 = require("../constants/bottleneck.const");
+const SkipBottleneckDecorator = () => (0, common_1.SetMetadata)(bottleneck_const_1.SKIP_CART_BOTTLENECK_KEY, true);
+exports.SkipBottleneckDecorator = SkipBottleneckDecorator;

package/dist/lib/bottleneck/decorators/use-bottleneck.decorator.d.ts

@@ -0,0 +1 @@
+export declare const UseBottleneckDecorator: () => import("@nestjs/common").CustomDecorator<string>;

package/dist/lib/bottleneck/decorators/use-bottleneck.decorator.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseBottleneckDecorator = void 0;
+const common_1 = require("@nestjs/common");
+const bottleneck_const_1 = require("../constants/bottleneck.const");
+const UseBottleneckDecorator = () => (0, common_1.SetMetadata)(bottleneck_const_1.USE_CART_BOTTLENECK_KEY, true);
+exports.UseBottleneckDecorator = UseBottleneckDecorator;

package/dist/lib/bottleneck/index.d.ts

@@ -0,0 +1,10 @@
+export * from './bottleneck.module';
+export * from './services/bottleneck.service';
+export * from './interceptors/bottleneck.interceptor';
+export * from './constants/bottleneck.const';
+export * from './interfaces/bottleneck-options.interface';
+export * from './decorators/config-bottleneck.decorator';
+export * from './cqrs-wrapper/queued-command-bus';
+export * from './cqrs-wrapper/queued-query-bus';
+export * from './decorators/skip-bottleneck.decorator';
+export * from './decorators/use-bottleneck.decorator';

package/dist/lib/bottleneck/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bottleneck.module"), exports);
+__exportStar(require("./services/bottleneck.service"), exports);
+__exportStar(require("./interceptors/bottleneck.interceptor"), exports);
+__exportStar(require("./constants/bottleneck.const"), exports);
+__exportStar(require("./interfaces/bottleneck-options.interface"), exports);
+__exportStar(require("./decorators/config-bottleneck.decorator"), exports);
+__exportStar(require("./cqrs-wrapper/queued-command-bus"), exports);
+__exportStar(require("./cqrs-wrapper/queued-query-bus"), exports);
+__exportStar(require("./decorators/skip-bottleneck.decorator"), exports);
+__exportStar(require("./decorators/use-bottleneck.decorator"), exports);

package/dist/lib/bottleneck/interceptors/bottleneck.interceptor.d.ts

@@ -0,0 +1,12 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { BottleneckService } from '../services/bottleneck.service';
+import { Reflector } from '@nestjs/core';
+import { BottleneckModuleOptions } from '../interfaces/bottleneck-options.interface';
+export declare class BottleneckInterceptor implements NestInterceptor {
+    private readonly options;
+    private readonly bottleneckService;
+    private readonly reflector;
+    private readonly logger;
+    constructor(options: BottleneckModuleOptions, bottleneckService: BottleneckService, reflector: Reflector);
+    intercept(ctx: ExecutionContext, next: CallHandler): import("rxjs").Observable<any>;
+}

package/dist/lib/bottleneck/interceptors/bottleneck.interceptor.js

@@ -0,0 +1,82 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var BottleneckInterceptor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BottleneckInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const bottleneck_service_1 = require("../services/bottleneck.service");
+const core_1 = require("@nestjs/core");
+const bottleneck_const_1 = require("../constants/bottleneck.const");
+const bottleneck_options_interface_1 = require("../interfaces/bottleneck-options.interface");
+let BottleneckInterceptor = BottleneckInterceptor_1 = class BottleneckInterceptor {
+    constructor(options, bottleneckService, reflector) {
+        this.options = options;
+        this.bottleneckService = bottleneckService;
+        this.reflector = reflector;
+        this.logger = new common_1.Logger(BottleneckInterceptor_1.name);
+    }
+    intercept(ctx, next) {
+        const host = ctx.getType();
+        if (host !== 'http') {
+            return next.handle();
+        }
+        const skip = this.reflector.getAllAndOverride(bottleneck_const_1.SKIP_CART_BOTTLENECK_KEY, [ctx.getHandler(), ctx.getClass()]);
+        const useBottleneck = this.reflector.getAllAndOverride(bottleneck_const_1.USE_CART_BOTTLENECK_KEY, [ctx.getHandler(), ctx.getClass()]);
+        const config = this.reflector.getAllAndOverride(bottleneck_const_1.CONFIG_CART_BOTTLENECK_KEY, [ctx.getHandler(), ctx.getClass()]);
+        const { basePath, paramKey, useGlobal, maxConcurrent, minTime, ...rest } = {
+            ...this.options,
+            ...config,
+        };
+        const url = ctx?.switchToHttp()?.getRequest()?.url;
+        if (skip || !(useBottleneck || useGlobal)) {
+            this.logger.debug(`🚀 Skipping Bottleneck for request: ${url}`);
+            return next.handle();
+        }
+        const req = ctx.switchToHttp().getRequest();
+        const param = req.params?.[paramKey];
+        if (!param) {
+            throw new common_1.ServiceUnavailableException(`${paramKey} is required in request: ${url}`);
+        }
+        const key = `${basePath}/${paramKey}:${param}`;
+        const bottleneckOptions = {
+            maxQueueSize: 100,
+            maxConcurrent: maxConcurrent || 1,
+            minTime: minTime || 0,
+            ...rest,
+        };
+        const method = req.method || 'UNKNOWN';
+        const start = Date.now();
+        this.logger.debug(`🔁 [Bottleneck] Scheduling job for key="${key}" method=${method} url=${url}`);
+        return (0, rxjs_1.from)(this.bottleneckService
+            .scheduleForKey(key, async () => (0, rxjs_1.lastValueFrom)(next.handle()), bottleneckOptions)
+            .catch((err) => {
+            if (String(err?.message || '').includes('This limiter is at max capacity')) {
+                throw new common_1.ServiceUnavailableException('Too many requests queued for this order. Try again soon.');
+            }
+            throw err;
+        })
+            .finally(() => {
+            const duration = Date.now() - start;
+            this.logger.debug(`✅ [Bottleneck] Finished job for key="${key}" method=${method} url=${url} duration=${duration}ms`);
+        }));
+    }
+};
+exports.BottleneckInterceptor = BottleneckInterceptor;
+exports.BottleneckInterceptor = BottleneckInterceptor = BottleneckInterceptor_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(bottleneck_options_interface_1.BOTTLENECK_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object, bottleneck_service_1.BottleneckService,
+        core_1.Reflector])
+], BottleneckInterceptor);

package/dist/lib/bottleneck/interfaces/bottleneck-options.interface.d.ts

@@ -0,0 +1,39 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+export declare const BOTTLENECK_MODULE_OPTIONS = "BOTTLENECK_MODULE_OPTIONS";
+export interface BottleneckModuleOptions {
+    appName?: string;
+    basePath?: string;
+    paramKey?: string;
+    useGlobal?: boolean;
+    maxConcurrent?: number | null;
+    minTime?: number | null;
+    highWater?: number | null;
+    penalty?: number | null;
+    reservoir?: number | null;
+    reservoirRefreshInterval?: number | null;
+    reservoirRefreshAmount?: number | null;
+    reservoirIncreaseAmount?: number | null;
+    reservoirIncreaseInterval?: number | null;
+    reservoirIncreaseMaximum?: number | null;
+    rejectOnDrop?: boolean | null;
+    trackDoneStatus?: boolean | null;
+    useRedis?: boolean;
+    redis?: {
+        host: string;
+        port: number;
+        username?: string;
+        password?: string;
+        database?: number;
+        ttl?: number;
+        tls?: boolean;
+    };
+}
+export interface BottleneckModuleFactory {
+    createModuleOptions: () => Promise<BottleneckModuleOptions> | BottleneckModuleOptions;
+}
+export interface BottleneckModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    inject?: any[];
+    useClass?: Type<BottleneckModuleFactory>;
+    useExisting?: Type<BottleneckModuleFactory>;
+    useFactory?: (...args: any[]) => Promise<BottleneckModuleOptions> | BottleneckModuleOptions;
+}

package/dist/lib/bottleneck/interfaces/bottleneck-options.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOTTLENECK_MODULE_OPTIONS = void 0;
+exports.BOTTLENECK_MODULE_OPTIONS = 'BOTTLENECK_MODULE_OPTIONS';

package/dist/lib/bottleneck/services/bottleneck.service.d.ts

@@ -0,0 +1,14 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import Bottleneck from 'bottleneck';
+import { BottleneckModuleOptions } from '../interfaces/bottleneck-options.interface';
+export declare class BottleneckService implements OnModuleDestroy {
+    private readonly options;
+    private readonly logger;
+    private readonly group;
+    private readonly cache;
+    constructor(options: BottleneckModuleOptions);
+    private getLimiter;
+    scheduleForKey<T>(key: string, task: () => Promise<T>, opts?: Bottleneck.ConstructorOptions): Promise<T>;
+    runQueuedTask<T>(key: string, fn: () => Promise<T>): Promise<T>;
+    onModuleDestroy(): Promise<void>;
+}