@taukirsheikh/rate-limiter 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohammed Taukir Sheikh
+
+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,490 @@
+# @custom/rate-limiter
+
+A powerful rate limiter for Node.js with TypeScript support and Redis clustering. Similar to [Bottleneck](https://www.npmjs.com/package/bottleneck) but built from scratch.
+
+## Features
+
+- 🚦 **Concurrency Control** - Limit max concurrent jobs
+- ⏱️ **Rate Limiting** - Min time between jobs, max per interval
+- 🪣 **Reservoir (Token Bucket)** - Finite pool with automatic refill
+- ⭐ **Priority Queues** - Higher priority jobs execute first
+- 🔄 **Retry Support** - Automatic retries with exponential backoff
+- ❌ **Cancellation** - Cancel by ID or AbortController
+- 📡 **Event Hooks** - Lifecycle events for monitoring
+- 📊 **Statistics** - Track wait times, execution times, success/failure
+- 🎁 **Function Wrapping** - Easily wrap existing async functions
+- 🌐 **Redis Clustering** - Distributed rate limiting across multiple servers
+
+## Installation
+
+```bash
+npm install @custom/rate-limiter
+```
+
+## Quick Start
+
+```typescript
+import { RateLimiter, Priority } from '@custom/rate-limiter';
+
+// Create a limiter
+const limiter = new RateLimiter({
+  maxConcurrent: 5,    // Max 5 concurrent requests
+  minTime: 100,        // 100ms minimum between requests
+});
+
+// Schedule a job
+const result = await limiter.schedule(async () => {
+  return await fetch('https://api.example.com/data');
+});
+```
+
+## Configuration Options
+
+```typescript
+interface RateLimiterOptions {
+  // Concurrency
+  maxConcurrent?: number;       // Max concurrent jobs (default: Infinity)
+
+  // Rate Limiting
+  minTime?: number;             // Min ms between job starts (default: 0)
+  maxPerInterval?: number;      // Max jobs per interval (default: Infinity)
+  interval?: number;            // Interval duration in ms (default: 1000)
+
+  // Reservoir (Token Bucket)
+  reservoir?: number;           // Initial reservoir size
+  reservoirRefreshInterval?: number;  // Refill interval in ms
+  reservoirRefreshAmount?: number;    // Amount to refill
+
+  // Queue Management
+  highWater?: number;           // Max queue size
+  strategy?: 'leak' | 'overflow' | 'block';  // Overflow strategy
+
+  // Retry
+  retryCount?: number;          // Auto-retry count (default: 0)
+  retryDelay?: number | ((attempt, error) => number);  // Retry delay
+
+  // Other
+  timeout?: number;             // Job timeout in ms
+  id?: string;                  // Limiter instance ID
+}
+```
+
+## Examples
+
+### Basic Rate Limiting
+
+```typescript
+const limiter = new RateLimiter({
+  maxConcurrent: 2,
+  minTime: 100,
+});
+
+const results = await Promise.all([
+  limiter.schedule(() => fetchUser(1)),
+  limiter.schedule(() => fetchUser(2)),
+  limiter.schedule(() => fetchUser(3)),
+]);
+```
+
+### Priority Queuing
+
+```typescript
+import { Priority } from '@custom/rate-limiter';
+
+// Critical jobs run first
+await limiter.schedule(
+  { priority: Priority.CRITICAL },
+  () => handleUrgentRequest()
+);
+
+// Low priority runs when queue is free
+await limiter.schedule(
+  { priority: Priority.LOW },
+  () => backgroundSync()
+);
+```
+
+### Reservoir (Token Bucket)
+
+```typescript
+const limiter = new RateLimiter({
+  reservoir: 10,                    // Start with 10 tokens
+  reservoirRefreshInterval: 60000,  // Refill every minute
+  reservoirRefreshAmount: 10,       // Refill to 10 tokens
+});
+
+// Each request uses 1 token
+// After 10 requests, must wait for refill
+```
+
+### Wrap Existing Functions
+
+```typescript
+const rateLimitedFetch = limiter.wrap(
+  async (url: string) => {
+    const response = await fetch(url);
+    return response.json();
+  }
+);
+
+// Use like a normal function
+const data = await rateLimitedFetch('/api/users');
+```
+
+### Retry with Exponential Backoff
+
+```typescript
+const limiter = new RateLimiter({
+  retryCount: 3,
+  retryDelay: (attempt, error) => Math.pow(2, attempt) * 1000,
+});
+
+// Will retry up to 3 times: 2s, 4s, 8s delays
+await limiter.schedule(() => unreliableApiCall());
+```
+
+### Cancellation
+
+```typescript
+// Cancel by ID
+limiter.schedule({ id: 'my-job' }, async () => { ... });
+limiter.cancel('my-job');
+
+// Cancel with AbortController
+const controller = new AbortController();
+limiter.schedule(
+  { signal: controller.signal },
+  async () => { ... }
+);
+controller.abort();
+```
+
+### Event Monitoring
+
+```typescript
+limiter.on('executing', ({ job, running }) => {
+  console.log(`Starting ${job.id}, ${running} jobs running`);
+});
+
+limiter.on('done', ({ job, duration }) => {
+  console.log(`Completed ${job.id} in ${duration}ms`);
+});
+
+limiter.on('failed', ({ job, error, willRetry }) => {
+  console.log(`Failed ${job.id}: ${error.message}`);
+});
+
+limiter.on('depleted', () => {
+  console.log('Reservoir empty, waiting for refill');
+});
+
+limiter.on('idle', () => {
+  console.log('All jobs complete');
+});
+```
+
+### Statistics
+
+```typescript
+const stats = limiter.getStats();
+console.log({
+  running: stats.running,
+  queued: stats.queued,
+  done: stats.done,
+  failed: stats.failed,
+  avgWaitTime: stats.avgWaitTime,
+  avgExecutionTime: stats.avgExecutionTime,
+});
+```
+
+---
+
+## 🌐 Distributed Rate Limiting with Redis
+
+For multi-server deployments, use `DistributedRateLimiter` to coordinate rate limits across all instances using Redis.
+
+### Quick Start (Redis)
+
+```typescript
+import { DistributedRateLimiter } from '@custom/rate-limiter';
+
+const limiter = new DistributedRateLimiter({
+  id: 'api-limiter',          // Shared ID across all servers
+  maxConcurrent: 10,          // 10 concurrent across ALL instances
+  minTime: 100,
+  redis: {
+    host: 'localhost',
+    port: 6379,
+    keyPrefix: 'myapp:ratelimit',
+  },
+});
+
+// Wait for Redis connection
+await limiter.ready();
+
+// Use like normal RateLimiter
+const result = await limiter.schedule(async () => {
+  return await fetch('https://api.example.com/data');
+});
+```
+
+### Redis Configuration
+
+```typescript
+interface RedisConnectionOptions {
+  // Connection
+  url?: string;                    // Redis URL (redis://...)
+  host?: string;                   // Redis host (default: localhost)
+  port?: number;                   // Redis port (default: 6379)
+  password?: string;               // Redis password
+  db?: number;                     // Database number
+
+  // Clustering
+  cluster?: boolean;               // Use Redis Cluster
+  clusterNodes?: Array<{host: string; port: number}>;
+
+  // Namespacing
+  keyPrefix?: string;              // Key prefix (default: 'ratelimit')
+
+  // Advanced
+  client?: Redis | Cluster;        // Existing ioredis client
+  redisOptions?: RedisOptions;     // Additional ioredis options
+}
+```
+
+### Multi-Server Example
+
+```typescript
+// Server 1
+const limiter1 = new DistributedRateLimiter({
+  id: 'shared-limiter',       // Same ID = shared limits
+  maxConcurrent: 5,
+  redis: { host: 'redis.example.com' },
+});
+
+// Server 2 (different machine)
+const limiter2 = new DistributedRateLimiter({
+  id: 'shared-limiter',       // Same ID!
+  maxConcurrent: 5,
+  redis: { host: 'redis.example.com' },
+});
+
+// Both servers share the 5 concurrent slot limit
+// If Server 1 has 3 running, Server 2 can only run 2
+```
+
+### Distributed Reservoir
+
+```typescript
+const limiter = new DistributedRateLimiter({
+  id: 'token-bucket',
+  reservoir: 100,                    // 100 tokens shared across all servers
+  reservoirRefreshInterval: 60000,   // Refill every minute
+  reservoirRefreshAmount: 100,
+  redis: { host: 'localhost' },
+});
+
+// All instances share the 100 token pool
+```
+
+### Redis Cluster Support
+
+```typescript
+const limiter = new DistributedRateLimiter({
+  id: 'cluster-limiter',
+  maxConcurrent: 50,
+  redis: {
+    cluster: true,
+    clusterNodes: [
+      { host: 'redis-1.example.com', port: 6379 },
+      { host: 'redis-2.example.com', port: 6379 },
+      { host: 'redis-3.example.com', port: 6379 },
+    ],
+  },
+});
+```
+
+### Using Existing Redis Client
+
+```typescript
+import Redis from 'ioredis';
+
+const redis = new Redis({ host: 'localhost', port: 6379 });
+
+const limiter = new DistributedRateLimiter({
+  id: 'shared-client',
+  maxConcurrent: 10,
+  redis: {
+    client: redis,  // Use existing client
+  },
+});
+```
+
+### Distributed Options
+
+```typescript
+interface DistributedRateLimiterOptions extends RateLimiterOptions {
+  redis: RedisConnectionOptions;
+
+  // Polling interval when waiting for slot (default: 50ms)
+  pollInterval?: number;
+
+  // Heartbeat interval to keep state alive (default: 30000ms)
+  heartbeatInterval?: number;
+
+  // Clear Redis state on start - useful for testing (default: false)
+  clearOnStart?: boolean;
+}
+```
+
+### How It Works
+
+The distributed limiter uses **Lua scripts** for atomic operations:
+
+1. **Acquire Slot**: Atomically checks concurrency, rate limits, and reservoir
+2. **Release Slot**: Atomically decrements running count and updates stats
+3. **All state lives in Redis**: Running count, interval counters, reservoir
+
+This ensures that even with multiple servers hitting Redis simultaneously, the rate limits are enforced correctly without race conditions.
+
+### State Persistence
+
+```typescript
+// State persists in Redis even when servers restart
+const state = await limiter.getState();
+console.log({
+  running: state.running,     // Currently running (across all servers)
+  done: state.done,           // Total completed
+  failed: state.failed,       // Total failed
+  reservoir: state.reservoir, // Current reservoir level
+});
+```
+
+### Graceful Degradation
+
+```typescript
+try {
+  const limiter = new DistributedRateLimiter({
+    id: 'api-limiter',
+    redis: { host: 'redis.example.com' },
+  });
+  await limiter.ready();
+} catch (error) {
+  console.log('Redis unavailable, falling back to local limiter');
+  // Fall back to non-distributed RateLimiter
+  const limiter = new RateLimiter({ maxConcurrent: 5 });
+}
+```
+
+---
+
+## API Reference
+
+### `RateLimiter`
+
+#### Methods
+
+| Method | Description |
+|--------|-------------|
+| `schedule(fn)` | Schedule a job for execution |
+| `schedule(options, fn)` | Schedule with options |
+| `wrap(fn, options?)` | Create a rate-limited version of a function |
+| `scheduleAll(jobs)` | Schedule multiple jobs |
+| `pause()` | Pause processing |
+| `resume()` | Resume processing |
+| `stop()` | Stop and reject all pending jobs |
+| `cancel(jobId)` | Cancel a specific job |
+| `waitForIdle()` | Wait for all jobs to complete |
+| `getState()` | Get current limiter state |
+| `getStats()` | Get detailed statistics |
+| `getQueued()` | Get queued jobs |
+| `updateReservoir(value)` | Set reservoir value |
+| `incrementReservoir(amount)` | Add to reservoir |
+| `isIdle()` | Check if limiter is idle |
+
+#### Events
+
+| Event | Data | Description |
+|-------|------|-------------|
+| `queued` | `{ job, position }` | Job added to queue |
+| `executing` | `{ job, queued, running }` | Job started |
+| `done` | `{ job, result, duration }` | Job completed |
+| `failed` | `{ job, error, willRetry }` | Job failed |
+| `retry` | `{ job, attempt, error }` | Job being retried |
+| `dropped` | `{ job, reason }` | Job dropped (overflow) |
+| `depleted` | - | Reservoir empty |
+| `idle` | - | All jobs complete |
+| `error` | `Error` | Error occurred |
+
+### `JobOptions`
+
+```typescript
+interface JobOptions {
+  priority?: number;      // Lower = higher priority (default: 5)
+  weight?: number;        // Concurrent slots used (default: 1)
+  id?: string;            // Unique job ID
+  timeout?: number;       // Job-specific timeout
+  retryCount?: number;    // Job-specific retry count
+  signal?: AbortSignal;   // For cancellation
+}
+```
+
+### `Priority` Enum
+
+```typescript
+enum Priority {
+  CRITICAL = 0,
+  HIGH = 3,
+  NORMAL = 5,
+  LOW = 7,
+  IDLE = 9,
+}
+```
+
+### `DistributedRateLimiter`
+
+Same methods as `RateLimiter`, plus:
+
+| Method | Description |
+|--------|-------------|
+| `ready()` | Wait for Redis connection (must call before use) |
+| `getStorage()` | Get underlying RedisStorage instance |
+| `clear()` | Clear all state from Redis |
+
+**Note:** `getState()` and `getStats()` are async for the distributed limiter.
+
+---
+
+## Running the Examples
+
+```bash
+cd rate-limiter
+npm install
+npm run example          # Local rate limiter examples
+npm run example:redis    # Distributed examples (requires Redis)
+```
+
+## Running Tests
+
+```bash
+npm test                 # Local rate limiter tests
+npm test:redis           # Distributed tests (requires Redis)
+```
+
+### Starting Redis for Tests
+
+```bash
+# Docker
+docker run -d -p 6379:6379 redis:alpine
+
+# macOS
+brew services start redis
+
+# Linux
+sudo systemctl start redis
+```
+
+## License
+
+MIT
+

package/dist/event-emitter.d.ts

@@ -0,0 +1,32 @@
+import type { EventListener, RateLimiterEvents } from './types.js';
+/**
+ * Type-safe event emitter for the rate limiter
+ */
+export declare class TypedEventEmitter {
+    private listeners;
+    /**
+     * Subscribe to an event
+     */
+    on<K extends keyof RateLimiterEvents>(event: K, listener: EventListener<RateLimiterEvents[K]>): () => void;
+    /**
+     * Subscribe to an event once
+     */
+    once<K extends keyof RateLimiterEvents>(event: K, listener: EventListener<RateLimiterEvents[K]>): () => void;
+    /**
+     * Unsubscribe from an event
+     */
+    off<K extends keyof RateLimiterEvents>(event: K, listener: EventListener<RateLimiterEvents[K]>): void;
+    /**
+     * Emit an event to all listeners
+     */
+    protected emit<K extends keyof RateLimiterEvents>(event: K, data: RateLimiterEvents[K]): void;
+    /**
+     * Remove all listeners for an event (or all events)
+     */
+    removeAllListeners(event?: keyof RateLimiterEvents): void;
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event: keyof RateLimiterEvents): number;
+}
+//# sourceMappingURL=event-emitter.d.ts.map

package/dist/event-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.d.ts","sourceRoot":"","sources":["../src/event-emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnE;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CAAmE;IAEpF;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,MAAM,iBAAiB,EAClC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAC5C,MAAM,IAAI;IAUb;;OAEG;IACH,IAAI,CAAC,CAAC,SAAS,MAAM,iBAAiB,EACpC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAC5C,MAAM,IAAI;IASb;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,iBAAiB,EACnC,KAAK,EAAE,CAAC,EACR,QAAQ,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAC5C,IAAI;IAIP;;OAEG;IACH,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,MAAM,iBAAiB,EAC9C,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,GACzB,IAAI;IAcP;;OAEG;IACH,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,iBAAiB,GAAG,IAAI;IAQzD;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,iBAAiB,GAAG,MAAM;CAGtD"}

package/dist/event-emitter.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEventEmitter = void 0;
+/**
+ * Type-safe event emitter for the rate limiter
+ */
+class TypedEventEmitter {
+    listeners = new Map();
+    /**
+     * Subscribe to an event
+     */
+    on(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(listener);
+        // Return unsubscribe function
+        return () => this.off(event, listener);
+    }
+    /**
+     * Subscribe to an event once
+     */
+    once(event, listener) {
+        const wrapper = ((data) => {
+            this.off(event, wrapper);
+            listener(data);
+        });
+        return this.on(event, wrapper);
+    }
+    /**
+     * Unsubscribe from an event
+     */
+    off(event, listener) {
+        this.listeners.get(event)?.delete(listener);
+    }
+    /**
+     * Emit an event to all listeners
+     */
+    emit(event, data) {
+        const eventListeners = this.listeners.get(event);
+        if (eventListeners) {
+            for (const listener of eventListeners) {
+                try {
+                    listener(data);
+                }
+                catch (error) {
+                    // Don't let listener errors break the emitter
+                    console.error(`Error in event listener for "${String(event)}":`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Remove all listeners for an event (or all events)
+     */
+    removeAllListeners(event) {
+        if (event) {
+            this.listeners.delete(event);
+        }
+        else {
+            this.listeners.clear();
+        }
+    }
+    /**
+     * Get listener count for an event
+     */
+    listenerCount(event) {
+        return this.listeners.get(event)?.size ?? 0;
+    }
+}
+exports.TypedEventEmitter = TypedEventEmitter;
+//# sourceMappingURL=event-emitter.js.map

package/dist/event-emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-emitter.js","sourceRoot":"","sources":["../src/event-emitter.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,MAAa,iBAAiB;IACpB,SAAS,GAAG,IAAI,GAAG,EAAwD,CAAC;IAEpF;;OAEG;IACH,EAAE,CACA,KAAQ,EACR,QAA6C;QAE7C,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC,GAAG,CAAC,QAAkC,CAAC,CAAC;QAEnE,8BAA8B;QAC9B,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,IAAI,CACF,KAAQ,EACR,QAA6C;QAE7C,MAAM,OAAO,GAAG,CAAC,CAAC,IAA0B,EAAE,EAAE;YAC9C,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACzB,QAAQ,CAAC,IAAI,CAAC,CAAC;QACjB,CAAC,CAAwC,CAAC;QAE1C,OAAO,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,GAAG,CACD,KAAQ,EACR,QAA6C;QAE7C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,QAAkC,CAAC,CAAC;IACxE,CAAC;IAED;;OAEG;IACO,IAAI,CACZ,KAAQ,EACR,IAA0B;QAE1B,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACjD,IAAI,cAAc,EAAE,CAAC;YACnB,KAAK,MAAM,QAAQ,IAAI,cAAc,EAAE,CAAC;gBACtC,IAAI,CAAC;oBACH,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACjB,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,8CAA8C;oBAC9C,OAAO,CAAC,KAAK,CAAC,gCAAgC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBAC1E,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAC,KAA+B;QAChD,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACzB,CAAC;IACH,CAAC;IAED;;OAEG;IACH,aAAa,CAAC,KAA8B;QAC1C,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC;IAC9C,CAAC;CACF;AAjFD,8CAiFC"}

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @custom/rate-limiter
+ *
+ * A powerful rate limiter with:
+ * - Concurrency control
+ * - Rate limiting (minTime, maxPerInterval)
+ * - Priority queues
+ * - Reservoir (token bucket) pattern
+ * - Task scheduling
+ * - Event hooks
+ * - Retry support
+ * - Abort signal support
+ * - Redis clustering for distributed systems
+ *
+ * @example
+ * ```ts
+ * import { RateLimiter, Priority } from '@custom/rate-limiter';
+ *
+ * const limiter = new RateLimiter({
+ *   maxConcurrent: 5,
+ *   minTime: 100,
+ * });
+ *
+ * const result = await limiter.schedule(async () => {
+ *   return await fetch('/api/data');
+ * });
+ * ```
+ *
+ * @example Distributed with Redis
+ * ```ts
+ * import { DistributedRateLimiter } from '@custom/rate-limiter';
+ *
+ * const limiter = new DistributedRateLimiter({
+ *   maxConcurrent: 10,
+ *   redis: { host: 'localhost', port: 6379 },
+ * });
+ *
+ * await limiter.ready();
+ * const result = await limiter.schedule(async () => fetchData());
+ * ```
+ */
+export { RateLimiter } from './rate-limiter.js';
+export { PriorityQueue } from './priority-queue.js';
+export { TypedEventEmitter } from './event-emitter.js';
+export { DistributedRateLimiter, RedisStorage, type DistributedRateLimiterOptions, type RedisConnectionOptions, type AcquireResult, type DistributedState, } from './redis/index.js';
+export { Priority, type RateLimiterOptions, type JobOptions, type Job, type LimiterState, type Stats, type RateLimiterEvents, type EventListener, type OverflowStrategy, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAGvD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,GAAG,EACR,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,gBAAgB,GACtB,MAAM,YAAY,CAAC"}