nest-ratelimit-pro 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alireza Aminzadeh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,359 @@
+# nest-ratelimit-pro
+
+[![npm version](https://badge.fury.io/js/nest-ratelimit-pro.svg)](https://www.npmjs.com/package/nest-ratelimit-pro)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Test Coverage](https://img.shields.io/badge/coverage-65%25-brightgreen.svg)](https://github.com/syeedalireza/nest-ratelimit-pro)
+
+Advanced rate limiting and throttling middleware for NestJS with support for multiple algorithms, distributed systems, and flexible storage backends.
+
+## 🚀 Features
+
+- **Multiple Rate Limiting Algorithms**
+  - Fixed Window Counter
+  - Sliding Window Log
+  - Token Bucket
+  - Sliding Window Counter
+
+- **Flexible Key Strategies**
+  - IP-based rate limiting
+  - User ID-based (requires authentication)
+  - API Key-based
+  - Custom key extraction
+
+- **Storage Backends**
+  - In-memory storage (single instance)
+  - Redis support (distributed)
+  - Custom storage adapters
+
+- **Advanced Features**
+  - Cost-based rate limiting
+  - Per-route configuration
+  - Skip conditions
+  - Automatic cleanup
+  - Response headers
+  - Custom error messages
+
+- **Production-Ready**
+  - TypeScript with strict typing
+  - Comprehensive test coverage
+  - Docker support
+  - Monitoring & metrics ready
+
+## 📦 Installation
+
+```bash
+npm install nest-ratelimit-pro
+```
+
+**Optional dependencies:**
+
+```bash
+# For Redis storage
+npm install ioredis
+```
+
+## 🔧 Quick Start
+
+### 1. Basic Setup
+
+```typescript
+import { Module } from '@nestjs/common';
+import { RateLimitModule } from 'nest-ratelimit-pro';
+
+@Module({
+  imports: [
+    RateLimitModule.forRoot({
+      limit: 100,              // 100 requests
+      duration: '1m',          // per 1 minute
+      keyStrategy: 'ip',       // Rate limit by IP address
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 2. Apply Guard to Controllers
+
+```typescript
+import { Controller, Get, UseGuards } from '@nestjs/common';
+import { RateLimitGuard } from 'nest-ratelimit-pro';
+
+@Controller('api')
+@UseGuards(RateLimitGuard)
+export class ApiController {
+  @Get('data')
+  async getData() {
+    return { message: 'Success!' };
+  }
+}
+```
+
+### 3. Per-Route Configuration
+
+```typescript
+import { RateLimit } from 'nest-ratelimit-pro';
+
+@Controller('api')
+export class ApiController {
+  // Override global limit for this route
+  @RateLimit({ limit: 5, duration: '1m' })
+  @Get('expensive')
+  async expensiveOperation() {
+    return { data: 'Heavy computation' };
+  }
+
+  // Skip rate limiting for this route
+  @SkipRateLimit()
+  @Get('health')
+  async healthCheck() {
+    return { status: 'ok' };
+  }
+}
+```
+
+## 📖 Configuration Options
+
+### Module Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `limit` | `number` | **Required** | Maximum requests allowed |
+| `duration` | `string` | **Required** | Time window (e.g., '1m', '1h') |
+| `algorithm` | `RateLimitAlgorithm` | `FIXED_WINDOW` | Algorithm to use |
+| `keyStrategy` | `RateLimitKeyStrategy` | `IP` | How to identify requesters |
+| `keyExtractor` | `Function` | - | Custom key extraction |
+| `storage` | `Type<RateLimitStorage>` | `MemoryStorage` | Storage backend |
+| `keyPrefix` | `string` | `'ratelimit:'` | Prefix for storage keys |
+| `apiKeyHeader` | `string` | `'X-API-Key'` | API key header name |
+| `enableCostBased` | `boolean` | `false` | Enable cost-based limiting |
+| `blockDuration` | `number` | `0` | Block duration in seconds |
+| `skipPaths` | `string[]` | `[]` | Paths to skip |
+| `enabled` | `boolean` | `true` | Enable/disable globally |
+| `errorMessage` | `string` | - | Custom error message |
+| `includeHeaders` | `boolean` | `true` | Include rate limit headers |
+
+## 🎯 Rate Limiting Algorithms
+
+### Fixed Window
+
+Simple counter that resets at fixed intervals:
+
+```typescript
+RateLimitModule.forRoot({
+  algorithm: RateLimitAlgorithm.FIXED_WINDOW,
+  limit: 100,
+  duration: '1m',
+});
+```
+
+**Pros:** Simple, low memory
+**Cons:** Burst at window edges
+
+### Sliding Window
+
+More accurate, prevents burst:
+
+```typescript
+RateLimitModule.forRoot({
+  algorithm: RateLimitAlgorithm.SLIDING_WINDOW,
+  limit: 100,
+  duration: '1m',
+});
+```
+
+**Pros:** Smooth rate limiting
+**Cons:** Higher memory usage
+
+### Token Bucket
+
+Allows bursts with token refill:
+
+```typescript
+RateLimitModule.forRoot({
+  algorithm: RateLimitAlgorithm.TOKEN_BUCKET,
+  limit: 100,
+  duration: '1m',
+});
+```
+
+**Pros:** Flexible, allows controlled bursts
+**Cons:** More complex
+
+## 🔑 Key Strategies
+
+### IP-Based
+
+```typescript
+RateLimitModule.forRoot({
+  keyStrategy: RateLimitKeyStrategy.IP,
+  limit: 100,
+  duration: '1m',
+});
+```
+
+### User ID-Based
+
+```typescript
+RateLimitModule.forRoot({
+  keyStrategy: RateLimitKeyStrategy.USER_ID,
+  limit: 1000,
+  duration: '1h',
+});
+```
+
+Requires authentication middleware that sets `request.user.id`.
+
+### API Key-Based
+
+```typescript
+RateLimitModule.forRoot({
+  keyStrategy: RateLimitKeyStrategy.API_KEY,
+  apiKeyHeader: 'X-API-Key',
+  limit: 10000,
+  duration: '1d',
+});
+```
+
+### Custom Key Extractor
+
+```typescript
+RateLimitModule.forRoot({
+  keyStrategy: RateLimitKeyStrategy.CUSTOM,
+  keyExtractor: (request) => {
+    return `${request.user?.id}-${request.headers['x-tenant-id']}`;
+  },
+  limit: 100,
+  duration: '1m',
+});
+```
+
+## 💰 Cost-Based Rate Limiting
+
+Assign different costs to different operations:
+
+```typescript
+@Controller('api')
+export class ApiController {
+  @RateLimit({ cost: 1 })
+  @Get('light')
+  async lightOperation() {
+    return { data: 'Quick response' };
+  }
+
+  @RateLimit({ cost: 10 })
+  @Post('heavy')
+  async heavyOperation() {
+    return { data: 'Expensive computation' };
+  }
+}
+```
+
+With a limit of 100, you can make:
+- 100 light operations, or
+- 10 heavy operations, or
+- Any combination totaling 100 cost
+
+## 🗄️ Storage Backends
+
+### Memory Storage (Default)
+
+```typescript
+import { MemoryRateLimitStorage } from 'nest-ratelimit-pro';
+
+RateLimitModule.forRoot({
+  storage: MemoryRateLimitStorage,
+  limit: 100,
+  duration: '1m',
+});
+```
+
+**Use for:** Single-instance applications
+
+### Redis Storage
+
+```typescript
+import { RedisRateLimitStorage } from 'nest-ratelimit-pro';
+
+RateLimitModule.forRoot({
+  storage: RedisRateLimitStorage,
+  redisUrl: 'redis://localhost:6379',
+  limit: 100,
+  duration: '1m',
+});
+```
+
+**Use for:** Distributed applications, multiple instances
+
+## 📊 Response Headers
+
+When rate limiting is active, these headers are included:
+
+```
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 45
+X-RateLimit-Reset: 1234567890
+Retry-After: 30  (when limit exceeded)
+```
+
+## 🛡️ Skip Conditions
+
+### Skip Specific Paths
+
+```typescript
+RateLimitModule.forRoot({
+  skipPaths: ['/health', '/metrics', '/public/*'],
+  limit: 100,
+  duration: '1m',
+});
+```
+
+### Skip with Custom Logic
+
+```typescript
+RateLimitModule.forRoot({
+  skipIf: (request) => {
+    return request.headers['x-internal-request'] === 'true';
+  },
+  limit: 100,
+  duration: '1m',
+});
+```
+
+## 🧪 Testing
+
+```bash
+npm test              # Run tests
+npm run test:cov      # With coverage
+npm run test:watch    # Watch mode
+```
+
+## 📝 Example Application
+
+See the [examples](./examples) directory for complete implementations:
+- Basic rate limiting
+- Cost-based limiting
+- Redis integration
+- Custom storage adapter
+
+## 🤝 Contributing
+
+Contributions are welcome! Please read [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## 📄 License
+
+MIT License - see [LICENSE](./LICENSE) file for details.
+
+## 👤 Author
+
+**Alireza Aminzadeh**
+- Email: alireza.aminzadeh@hotmail.com
+- GitHub: [@syeedalireza](https://github.com/syeedalireza)
+- NPM: [@syeedalireza](https://www.npmjs.com/~syeedalireza)
+
+## ⭐ Support
+
+If this package helped you, please give it a ⭐ on [GitHub](https://github.com/syeedalireza/nest-ratelimit-pro)!
+
+---
+
+**Built with ❤️ for the NestJS community**

package/dist/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const RATE_LIMIT_OPTIONS = "RATE_LIMIT_OPTIONS";
+export declare const RATE_LIMIT_STORAGE = "RATE_LIMIT_STORAGE";
+export declare const RATE_LIMIT_SERVICE = "RATE_LIMIT_SERVICE";
+export declare const RATE_LIMIT_METADATA_KEY = "ratelimit:metadata";
+export declare const DEFAULT_KEY_PREFIX = "ratelimit:";
+export declare const DEFAULT_API_KEY_HEADER = "X-API-Key";
+export declare const DEFAULT_LIMIT = 100;
+export declare const DEFAULT_DURATION = "1m";
+export declare const HEADER_LIMIT = "X-RateLimit-Limit";
+export declare const HEADER_REMAINING = "X-RateLimit-Remaining";
+export declare const HEADER_RESET = "X-RateLimit-Reset";
+export declare const HEADER_RETRY_AFTER = "Retry-After";
+export declare const DEFAULT_ERROR_MESSAGE = "Too many requests. Please try again later.";

package/dist/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ERROR_MESSAGE = exports.HEADER_RETRY_AFTER = exports.HEADER_RESET = exports.HEADER_REMAINING = exports.HEADER_LIMIT = exports.DEFAULT_DURATION = exports.DEFAULT_LIMIT = exports.DEFAULT_API_KEY_HEADER = exports.DEFAULT_KEY_PREFIX = exports.RATE_LIMIT_METADATA_KEY = exports.RATE_LIMIT_SERVICE = exports.RATE_LIMIT_STORAGE = exports.RATE_LIMIT_OPTIONS = void 0;
+exports.RATE_LIMIT_OPTIONS = 'RATE_LIMIT_OPTIONS';
+exports.RATE_LIMIT_STORAGE = 'RATE_LIMIT_STORAGE';
+exports.RATE_LIMIT_SERVICE = 'RATE_LIMIT_SERVICE';
+exports.RATE_LIMIT_METADATA_KEY = 'ratelimit:metadata';
+exports.DEFAULT_KEY_PREFIX = 'ratelimit:';
+exports.DEFAULT_API_KEY_HEADER = 'X-API-Key';
+exports.DEFAULT_LIMIT = 100;
+exports.DEFAULT_DURATION = '1m';
+exports.HEADER_LIMIT = 'X-RateLimit-Limit';
+exports.HEADER_REMAINING = 'X-RateLimit-Remaining';
+exports.HEADER_RESET = 'X-RateLimit-Reset';
+exports.HEADER_RETRY_AFTER = 'Retry-After';
+exports.DEFAULT_ERROR_MESSAGE = 'Too many requests. Please try again later.';
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAGa,QAAA,kBAAkB,GAAG,oBAAoB,CAAC;AAC1C,QAAA,kBAAkB,GAAG,oBAAoB,CAAC;AAC1C,QAAA,kBAAkB,GAAG,oBAAoB,CAAC;AAK1C,QAAA,uBAAuB,GAAG,oBAAoB,CAAC;AAK/C,QAAA,kBAAkB,GAAG,YAAY,CAAC;AAClC,QAAA,sBAAsB,GAAG,WAAW,CAAC;AACrC,QAAA,aAAa,GAAG,GAAG,CAAC;AACpB,QAAA,gBAAgB,GAAG,IAAI,CAAC;AAKxB,QAAA,YAAY,GAAG,mBAAmB,CAAC;AACnC,QAAA,gBAAgB,GAAG,uBAAuB,CAAC;AAC3C,QAAA,YAAY,GAAG,mBAAmB,CAAC;AACnC,QAAA,kBAAkB,GAAG,aAAa,CAAC;AAKnC,QAAA,qBAAqB,GAAG,4CAA4C,CAAC"}

package/dist/decorators/rate-limit.decorator.d.ts

@@ -0,0 +1,3 @@
+import { RateLimitDecoratorOptions } from '../interfaces/rate-limit-options.interface';
+export declare const RateLimit: (options?: RateLimitDecoratorOptions) => MethodDecorator;
+export declare const SkipRateLimit: () => MethodDecorator;

package/dist/decorators/rate-limit.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkipRateLimit = exports.RateLimit = void 0;
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const RateLimit = (options) => {
+    return (0, common_1.SetMetadata)(constants_1.RATE_LIMIT_METADATA_KEY, options || {});
+};
+exports.RateLimit = RateLimit;
+const SkipRateLimit = () => {
+    return (0, common_1.SetMetadata)(constants_1.RATE_LIMIT_METADATA_KEY, { skip: true });
+};
+exports.SkipRateLimit = SkipRateLimit;
+//# sourceMappingURL=rate-limit.decorator.js.map

package/dist/decorators/rate-limit.decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.decorator.js","sourceRoot":"","sources":["../../src/decorators/rate-limit.decorator.ts"],"names":[],"mappings":";;;AAAA,2CAA6C;AAE7C,4CAAuD;AAyBhD,MAAM,SAAS,GAAG,CAAC,OAAmC,EAAmB,EAAE;IAChF,OAAO,IAAA,oBAAW,EAAC,mCAAuB,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;AAC7D,CAAC,CAAC;AAFW,QAAA,SAAS,aAEpB;AAcK,MAAM,aAAa,GAAG,GAAoB,EAAE;IACjD,OAAO,IAAA,oBAAW,EAAC,mCAAuB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,CAAC,CAAC;AAFW,QAAA,aAAa,iBAExB"}

package/dist/exceptions/rate-limit.exception.d.ts

@@ -0,0 +1,5 @@
+import { HttpException } from '@nestjs/common';
+export declare class RateLimitExceededException extends HttpException {
+    readonly retryAfter?: number | undefined;
+    constructor(message?: string, retryAfter?: number | undefined);
+}

package/dist/exceptions/rate-limit.exception.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitExceededException = void 0;
+const common_1 = require("@nestjs/common");
+class RateLimitExceededException extends common_1.HttpException {
+    constructor(message = 'Too many requests. Please try again later.', retryAfter) {
+        super({
+            statusCode: common_1.HttpStatus.TOO_MANY_REQUESTS,
+            message,
+            error: 'Too Many Requests',
+            retryAfter,
+        }, common_1.HttpStatus.TOO_MANY_REQUESTS);
+        this.retryAfter = retryAfter;
+    }
+}
+exports.RateLimitExceededException = RateLimitExceededException;
+//# sourceMappingURL=rate-limit.exception.js.map

package/dist/exceptions/rate-limit.exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.exception.js","sourceRoot":"","sources":["../../src/exceptions/rate-limit.exception.ts"],"names":[],"mappings":";;;AAAA,2CAA2D;AAK3D,MAAa,0BAA2B,SAAQ,sBAAa;IAC3D,YACE,UAAkB,4CAA4C,EAC9C,UAAmB;QAEnC,KAAK,CACH;YACE,UAAU,EAAE,mBAAU,CAAC,iBAAiB;YACxC,OAAO;YACP,KAAK,EAAE,mBAAmB;YAC1B,UAAU;SACX,EACD,mBAAU,CAAC,iBAAiB,CAC7B,CAAC;QAVc,eAAU,GAAV,UAAU,CAAS;IAWrC,CAAC;CACF;AAfD,gEAeC"}

package/dist/guards/rate-limit.guard.d.ts

@@ -0,0 +1,12 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { RateLimitService } from '../services/rate-limit.service';
+import { RateLimitModuleOptions } from '../interfaces/rate-limit-options.interface';
+export declare class RateLimitGuard implements CanActivate {
+    private readonly reflector;
+    private readonly rateLimitService;
+    private readonly options;
+    constructor(reflector: Reflector, rateLimitService: RateLimitService, options: RateLimitModuleOptions);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+    private shouldSkipPath;
+}

package/dist/guards/rate-limit.guard.js

@@ -0,0 +1,75 @@
+"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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitGuard = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rate_limit_service_1 = require("../services/rate-limit.service");
+const rate_limit_exception_1 = require("../exceptions/rate-limit.exception");
+const constants_1 = require("../constants");
+const constants_2 = require("../constants");
+let RateLimitGuard = class RateLimitGuard {
+    constructor(reflector, rateLimitService, options) {
+        this.reflector = reflector;
+        this.rateLimitService = rateLimitService;
+        this.options = options;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const response = context.switchToHttp().getResponse();
+        const decoratorOptions = this.reflector.get(constants_1.RATE_LIMIT_METADATA_KEY, context.getHandler());
+        if (decoratorOptions?.skip) {
+            return true;
+        }
+        if (this.shouldSkipPath(request.path)) {
+            return true;
+        }
+        const result = await this.rateLimitService.check(request, {
+            cost: decoratorOptions?.cost,
+        });
+        if (this.options.includeHeaders !== false) {
+            response.setHeader(constants_1.HEADER_LIMIT, result.limit.toString());
+            response.setHeader(constants_1.HEADER_REMAINING, result.remaining.toString());
+            response.setHeader(constants_1.HEADER_RESET, result.resetAt.toString());
+        }
+        if (!result.allowed) {
+            if (result.retryAfter) {
+                response.setHeader(constants_1.HEADER_RETRY_AFTER, result.retryAfter.toString());
+            }
+            const errorMessage = decoratorOptions?.errorMessage || this.options.errorMessage || constants_1.DEFAULT_ERROR_MESSAGE;
+            throw new rate_limit_exception_1.RateLimitExceededException(errorMessage, result.retryAfter);
+        }
+        return true;
+    }
+    shouldSkipPath(path) {
+        if (!this.options.skipPaths || this.options.skipPaths.length === 0) {
+            return false;
+        }
+        return this.options.skipPaths.some((skipPath) => {
+            if (skipPath.endsWith('*')) {
+                const prefix = skipPath.slice(0, -1);
+                return path.startsWith(prefix);
+            }
+            return path === skipPath;
+        });
+    }
+};
+exports.RateLimitGuard = RateLimitGuard;
+exports.RateLimitGuard = RateLimitGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(2, (0, common_1.Inject)(constants_2.RATE_LIMIT_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.Reflector,
+        rate_limit_service_1.RateLimitService, Object])
+], RateLimitGuard);
+//# sourceMappingURL=rate-limit.guard.js.map

package/dist/guards/rate-limit.guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.guard.js","sourceRoot":"","sources":["../../src/guards/rate-limit.guard.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from './rate-limit.module';
+export * from './services/rate-limit.service';
+export * from './guards/rate-limit.guard';
+export * from './decorators/rate-limit.decorator';
+export * from './interfaces/rate-limit.interface';
+export * from './interfaces/rate-limit-options.interface';
+export * from './interfaces/storage.interface';
+export * from './storage/memory.storage';
+export * from './exceptions/rate-limit.exception';
+export * from './constants';
+export * from './utils/time-utils';
+export * from './utils/key.utils';

package/dist/index.js

@@ -0,0 +1,29 @@
+"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("./rate-limit.module"), exports);
+__exportStar(require("./services/rate-limit.service"), exports);
+__exportStar(require("./guards/rate-limit.guard"), exports);
+__exportStar(require("./decorators/rate-limit.decorator"), exports);
+__exportStar(require("./interfaces/rate-limit.interface"), exports);
+__exportStar(require("./interfaces/rate-limit-options.interface"), exports);
+__exportStar(require("./interfaces/storage.interface"), exports);
+__exportStar(require("./storage/memory.storage"), exports);
+__exportStar(require("./exceptions/rate-limit.exception"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils/time-utils"), exports);
+__exportStar(require("./utils/key.utils"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AACA,sDAAoC;AAGpC,gEAA8C;AAG9C,4DAA0C;AAG1C,oEAAkD;AAGlD,oEAAkD;AAClD,4EAA0D;AAC1D,iEAA+C;AAG/C,2DAAyC;AAGzC,oEAAkD;AAGlD,8CAA4B;AAG5B,qDAAmC;AACnC,oDAAkC"}

package/dist/interfaces/rate-limit-options.interface.d.ts

@@ -0,0 +1,45 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+import { RateLimitStorage } from './storage.interface';
+export declare enum RateLimitAlgorithm {
+    TOKEN_BUCKET = "token-bucket",
+    FIXED_WINDOW = "fixed-window",
+    SLIDING_WINDOW = "sliding-window",
+    SLIDING_WINDOW_COUNTER = "sliding-window-counter"
+}
+export declare enum RateLimitKeyStrategy {
+    IP = "ip",
+    USER_ID = "user-id",
+    API_KEY = "api-key",
+    CUSTOM = "custom",
+    COMBINED = "combined"
+}
+export interface RateLimitModuleOptions {
+    algorithm?: RateLimitAlgorithm;
+    limit: number;
+    duration: string;
+    keyStrategy?: RateLimitKeyStrategy;
+    keyExtractor?: (request: any) => string | Promise<string>;
+    storage?: Type<RateLimitStorage>;
+    redisUrl?: string;
+    keyPrefix?: string;
+    apiKeyHeader?: string;
+    enableCostBased?: boolean;
+    blockDuration?: number;
+    skipPaths?: string[];
+    skipIf?: (request: any) => boolean | Promise<boolean>;
+    enabled?: boolean;
+    errorMessage?: string;
+    includeHeaders?: boolean;
+}
+export interface RateLimitModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useFactory?: (...args: any[]) => Promise<RateLimitModuleOptions> | RateLimitModuleOptions;
+    inject?: any[];
+}
+export interface RateLimitDecoratorOptions {
+    limit?: number;
+    duration?: string;
+    keyExtractor?: (request: any) => string | Promise<string>;
+    cost?: number;
+    skip?: boolean;
+    errorMessage?: string;
+}

package/dist/interfaces/rate-limit-options.interface.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitKeyStrategy = exports.RateLimitAlgorithm = void 0;
+var RateLimitAlgorithm;
+(function (RateLimitAlgorithm) {
+    RateLimitAlgorithm["TOKEN_BUCKET"] = "token-bucket";
+    RateLimitAlgorithm["FIXED_WINDOW"] = "fixed-window";
+    RateLimitAlgorithm["SLIDING_WINDOW"] = "sliding-window";
+    RateLimitAlgorithm["SLIDING_WINDOW_COUNTER"] = "sliding-window-counter";
+})(RateLimitAlgorithm || (exports.RateLimitAlgorithm = RateLimitAlgorithm = {}));
+var RateLimitKeyStrategy;
+(function (RateLimitKeyStrategy) {
+    RateLimitKeyStrategy["IP"] = "ip";
+    RateLimitKeyStrategy["USER_ID"] = "user-id";
+    RateLimitKeyStrategy["API_KEY"] = "api-key";
+    RateLimitKeyStrategy["CUSTOM"] = "custom";
+    RateLimitKeyStrategy["COMBINED"] = "combined";
+})(RateLimitKeyStrategy || (exports.RateLimitKeyStrategy = RateLimitKeyStrategy = {}));
+//# sourceMappingURL=rate-limit-options.interface.js.map