@geekmidas/rate-limit 0.1.0

package/README.md

@@ -0,0 +1,504 @@
+# @geekmidas/rate-limit
+
+Flexible rate limiting library with support for multiple cache backends, customizable key generation, and full TypeScript support.
+
+## Features
+
+- **Multiple Cache Backends**: Works with any cache implementation (Redis, In-Memory, etc.)
+- **Flexible Key Generation**: Customize how clients are identified
+- **Skip Logic**: Conditionally skip rate limiting for certain requests
+- **Standard Headers**: Automatic rate limit header generation
+- **Type-Safe**: Full TypeScript support with generic types
+- **Customizable**: Configure limits, windows, messages, and handlers
+- **IP Detection**: Automatic client IP detection from various headers
+
+## Installation
+
+```bash
+pnpm add @geekmidas/rate-limit
+```
+
+## Quick Start
+
+### Basic Usage
+
+```typescript
+import { checkRateLimit } from '@geekmidas/rate-limit';
+import { InMemoryCache } from '@geekmidas/cache/memory';
+
+const config = {
+  limit: 10,                           // 10 requests
+  windowMs: 60000,                     // per 1 minute
+  cache: new InMemoryCache(),          // storage backend
+};
+
+// In your handler
+try {
+  const info = await checkRateLimit(config, {
+    header: (key) => request.headers.get(key),
+    services: {},
+    logger,
+    session: null,
+    path: '/api/users',
+    method: 'GET'
+  });
+
+  // Request allowed
+  console.log(`${info.remaining} requests remaining`);
+} catch (error) {
+  if (error instanceof TooManyRequestsError) {
+    // Rate limit exceeded
+    console.log(`Try again in ${error.retryAfter} seconds`);
+  }
+}
+```
+
+### With Endpoints
+
+Rate limiting is built into the constructs package:
+
+```typescript
+import { e } from '@geekmidas/constructs/endpoints';
+import { InMemoryCache } from '@geekmidas/cache/memory';
+import { z } from 'zod';
+
+export const sendMessage = e
+  .post('/api/messages')
+  .rateLimit({
+    limit: 10,                    // 10 requests
+    windowMs: 60000,             // per minute
+    cache: new InMemoryCache(),
+    message: 'Too many messages sent. Please try again later.'
+  })
+  .body(z.object({
+    content: z.string()
+  }))
+  .handle(async ({ body }) => {
+    // Rate limited to 10 requests per minute
+    return { success: true };
+  });
+```
+
+## Configuration
+
+### RateLimitConfig
+
+```typescript
+interface RateLimitConfig {
+  limit: number;           // Max requests in window
+  windowMs: number;        // Time window in milliseconds
+  cache: Cache;            // Cache backend
+  keyGenerator?: RateLimitKeyGenerator; // Custom key generation
+  skip?: RateLimitSkipFn;  // Skip certain requests
+  message?: string;        // Custom error message
+  handler?: RateLimitExceededHandler; // Custom exceeded handler
+  standardHeaders?: boolean; // Include standard headers (default: true)
+  legacyHeaders?: boolean;   // Include legacy headers (default: false)
+}
+```
+
+## Cache Backends
+
+### In-Memory Cache
+
+Best for development and single-instance deployments:
+
+```typescript
+import { InMemoryCache } from '@geekmidas/cache/memory';
+
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache()
+};
+```
+
+### Redis (Upstash)
+
+Best for production and distributed systems:
+
+```typescript
+import { UpstashCache } from '@geekmidas/cache/upstash';
+
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new UpstashCache({
+    url: process.env.UPSTASH_REDIS_URL,
+    token: process.env.UPSTASH_REDIS_TOKEN
+  })
+};
+```
+
+## Custom Key Generation
+
+### By User ID
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  keyGenerator: (ctx) => {
+    const userId = ctx.session?.userId || 'anonymous';
+    return `rate-limit:${ctx.method}:${ctx.path}:${userId}`;
+  }
+};
+```
+
+### By API Key
+
+```typescript
+const config = {
+  limit: 1000,
+  windowMs: 3600000, // 1 hour
+  cache: new InMemoryCache(),
+  keyGenerator: (ctx) => {
+    const apiKey = ctx.header('x-api-key') || 'unknown';
+    return `rate-limit:${ctx.path}:${apiKey}`;
+  }
+};
+```
+
+### By IP and User Agent
+
+```typescript
+const config = {
+  limit: 50,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  keyGenerator: (ctx) => {
+    const ip = ctx.header('x-forwarded-for')?.split(',')[0] || 'unknown';
+    const userAgent = ctx.header('user-agent') || 'unknown';
+    return `rate-limit:${ip}:${userAgent}`;
+  }
+};
+```
+
+## Skip Logic
+
+### Skip Authenticated Users
+
+```typescript
+const config = {
+  limit: 10,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  skip: (ctx) => {
+    // Skip rate limiting for authenticated users
+    return !!ctx.session?.userId;
+  }
+};
+```
+
+### Skip Admin Routes
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  skip: (ctx) => {
+    // Skip rate limiting for admin routes
+    return ctx.path.startsWith('/admin/');
+  }
+};
+```
+
+### Skip Internal IPs
+
+```typescript
+const config = {
+  limit: 10,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  skip: (ctx) => {
+    const ip = ctx.header('x-forwarded-for')?.split(',')[0];
+    // Skip rate limiting for internal IPs
+    return ip?.startsWith('10.') || ip?.startsWith('192.168.');
+  }
+};
+```
+
+## Custom Handlers
+
+### Log Rate Limit Violations
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  handler: async (ctx, info) => {
+    ctx.logger.warn({
+      path: ctx.path,
+      method: ctx.method,
+      count: info.count,
+      limit: info.limit,
+      ip: ctx.header('x-forwarded-for')
+    }, 'Rate limit exceeded');
+  }
+};
+```
+
+### Alert on Abuse
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  handler: async (ctx, info) => {
+    // Alert if significantly over limit
+    if (info.count > info.limit * 2) {
+      await alertService.send({
+        type: 'rate_limit_abuse',
+        ip: ctx.header('x-forwarded-for'),
+        count: info.count,
+        path: ctx.path
+      });
+    }
+  }
+};
+```
+
+## Response Headers
+
+The library automatically sets standard rate limit headers:
+
+```
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 95
+X-RateLimit-Reset: 2024-01-15T12:34:56.789Z
+Retry-After: 45
+```
+
+### Disable Headers
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  standardHeaders: false  // Disable standard headers
+};
+```
+
+### Enable Legacy Headers
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  legacyHeaders: true  // Enable legacy headers
+};
+```
+
+## Rate Limit Info
+
+The `checkRateLimit` function returns information about the current rate limit status:
+
+```typescript
+interface RateLimitInfo {
+  count: number;        // Current request count
+  limit: number;        // Max allowed requests
+  remaining: number;    // Remaining requests
+  resetTime: number;    // Unix timestamp when window resets
+  retryAfter: number;   // Milliseconds until reset
+}
+
+const info = await checkRateLimit(config, ctx);
+console.log(`You have ${info.remaining} requests remaining`);
+console.log(`Rate limit resets at ${new Date(info.resetTime)}`);
+```
+
+## Error Handling
+
+### TooManyRequestsError
+
+Thrown when rate limit is exceeded:
+
+```typescript
+import { TooManyRequestsError } from '@geekmidas/rate-limit';
+
+try {
+  await checkRateLimit(config, ctx);
+} catch (error) {
+  if (error instanceof TooManyRequestsError) {
+    console.log(`Status: ${error.statusCode}`); // 429
+    console.log(`Message: ${error.message}`);
+    console.log(`Retry after: ${error.retryAfter} seconds`);
+
+    // Send appropriate response
+    return new Response(error.message, {
+      status: error.statusCode,
+      headers: {
+        'Retry-After': error.retryAfter?.toString() || '60'
+      }
+    });
+  }
+}
+```
+
+## Common Patterns
+
+### Different Limits for Different Endpoints
+
+```typescript
+// Strict limit for auth endpoints
+export const login = e
+  .post('/auth/login')
+  .rateLimit({
+    limit: 5,
+    windowMs: 300000, // 5 minutes
+    cache: new InMemoryCache(),
+    message: 'Too many login attempts. Please try again later.'
+  })
+  .handle(async () => {
+    // Login logic
+  });
+
+// Generous limit for read endpoints
+export const getUsers = e
+  .get('/users')
+  .rateLimit({
+    limit: 1000,
+    windowMs: 60000, // 1 minute
+    cache: new InMemoryCache()
+  })
+  .handle(async () => {
+    // Get users logic
+  });
+```
+
+### Tiered Rate Limits
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache: new InMemoryCache(),
+  keyGenerator: (ctx) => {
+    // Different limits based on user tier
+    const tier = ctx.session?.tier || 'free';
+    const limit = tier === 'premium' ? 1000 : 100;
+
+    return `rate-limit:${tier}:${ctx.path}:${ctx.session?.userId}`;
+  }
+};
+```
+
+### Per-API-Key Limits
+
+```typescript
+const config = {
+  limit: 10000,
+  windowMs: 3600000, // 1 hour
+  cache: new UpstashCache({ /* config */ }),
+  keyGenerator: (ctx) => {
+    const apiKey = ctx.header('x-api-key');
+    if (!apiKey) {
+      throw new Error('API key required');
+    }
+    return `rate-limit:api-key:${apiKey}`;
+  },
+  message: 'API rate limit exceeded. Upgrade your plan for higher limits.'
+};
+```
+
+## Testing
+
+Mock the cache for testing:
+
+```typescript
+import { checkRateLimit, type RateLimitData } from '@geekmidas/rate-limit';
+import { vi } from 'vitest';
+
+const mockCache = {
+  get: vi.fn(),
+  set: vi.fn(),
+  delete: vi.fn()
+};
+
+const config = {
+  limit: 10,
+  windowMs: 60000,
+  cache: mockCache as any
+};
+
+// Test rate limit not exceeded
+mockCache.get.mockResolvedValue({ count: 5, resetTime: Date.now() + 30000 });
+
+const info = await checkRateLimit(config, ctx);
+expect(info.remaining).toBe(5);
+
+// Test rate limit exceeded
+mockCache.get.mockResolvedValue({ count: 11, resetTime: Date.now() + 30000 });
+
+await expect(checkRateLimit(config, ctx)).rejects.toThrow(TooManyRequestsError);
+```
+
+## Best Practices
+
+### 1. Use Redis in Production
+
+```typescript
+// ✅ Use Redis for distributed systems
+import { UpstashCache } from '@geekmidas/cache/upstash';
+
+const cache = new UpstashCache({ /* config */ });
+
+// ❌ Don't use in-memory cache in production
+const cache = new InMemoryCache(); // Only for dev/testing
+```
+
+### 2. Set Appropriate Limits
+
+```typescript
+// ✅ Different limits for different operations
+const authConfig = { limit: 5, windowMs: 300000 }; // 5 per 5 min
+const readConfig = { limit: 1000, windowMs: 60000 }; // 1000 per min
+
+// ❌ Don't use same limit for everything
+const config = { limit: 100, windowMs: 60000 }; // Too generic
+```
+
+### 3. Include Helpful Error Messages
+
+```typescript
+// ✅ Clear, actionable messages
+message: 'Rate limit exceeded. You can make 100 requests per minute. Please try again in 45 seconds.'
+
+// ❌ Generic messages
+message: 'Too many requests'
+```
+
+### 4. Log Rate Limit Events
+
+```typescript
+const config = {
+  limit: 100,
+  windowMs: 60000,
+  cache,
+  handler: async (ctx, info) => {
+    ctx.logger.warn({
+      event: 'rate_limit_exceeded',
+      path: ctx.path,
+      count: info.count,
+      limit: info.limit
+    }, 'Rate limit exceeded');
+  }
+};
+```
+
+## Related Packages
+
+- [@geekmidas/cache](../cache) - Cache implementations for rate limiting
+- [@geekmidas/constructs](../constructs) - Built-in rate limiting for endpoints
+- [@geekmidas/errors](../errors) - HTTP error classes
+- [@geekmidas/logger](../logger) - Structured logging
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,88 @@
+
+//#region src/index.ts
+/**
+* Error thrown when rate limit is exceeded
+*/
+var TooManyRequestsError = class extends Error {
+	statusCode = 429;
+	retryAfter;
+	constructor(message, retryAfter) {
+		super(message || "Too many requests, please try again later.");
+		this.name = "TooManyRequestsError";
+		this.retryAfter = retryAfter;
+	}
+};
+/**
+* Default key generator using IP address
+*/
+const defaultKeyGenerator = (ctx) => {
+	const ip = ctx.header("x-forwarded-for")?.split(",")[0]?.trim() || ctx.header("x-real-ip") || ctx.header("x-client-ip") || ctx.header("cf-connecting-ip") || "unknown";
+	return `rate-limit:${ctx.method}:${ctx.path}:${ip}`;
+};
+/**
+* Check rate limit and throw error if exceeded
+*/
+async function checkRateLimit(config, ctx) {
+	if (config.skip && await config.skip(ctx)) return {
+		count: 0,
+		limit: config.limit,
+		remaining: config.limit,
+		resetTime: Date.now() + config.windowMs,
+		retryAfter: config.windowMs
+	};
+	const keyGenerator = config.keyGenerator || defaultKeyGenerator;
+	const key = await keyGenerator(ctx);
+	const now = Date.now();
+	let data = await config.cache.get(key);
+	if (!data || data.resetTime <= now) {
+		const resetTime = now + config.windowMs;
+		data = {
+			count: 1,
+			resetTime
+		};
+		const ttlSeconds = Math.ceil(config.windowMs / 1e3);
+		await config.cache.set(key, data, ttlSeconds);
+	} else {
+		data.count++;
+		const remainingMs = data.resetTime - now;
+		const ttlSeconds = Math.ceil(remainingMs / 1e3);
+		await config.cache.set(key, data, ttlSeconds);
+	}
+	const info = {
+		count: data.count,
+		limit: config.limit,
+		remaining: Math.max(0, config.limit - data.count),
+		resetTime: data.resetTime,
+		retryAfter: data.resetTime - now
+	};
+	if (data.count > config.limit) {
+		if (config.handler) await config.handler(ctx, info);
+		const retryAfterSeconds = Math.ceil(info.retryAfter / 1e3);
+		throw new TooManyRequestsError(config.message || "Too many requests, please try again later.", retryAfterSeconds);
+	}
+	return info;
+}
+/**
+* Generate rate limit headers
+*/
+function getRateLimitHeaders(info, config) {
+	const headers = {};
+	if (config.standardHeaders !== false) {
+		headers["X-RateLimit-Limit"] = info.limit.toString();
+		headers["X-RateLimit-Remaining"] = info.remaining.toString();
+		headers["X-RateLimit-Reset"] = new Date(info.resetTime).toISOString();
+	}
+	if (config.legacyHeaders) {
+		headers["X-RateLimit-Retry-After"] = info.retryAfter.toString();
+		headers["X-RateLimit-Reset-After"] = Math.ceil(info.retryAfter / 1e3).toString();
+	}
+	if (info.remaining === 0) headers["Retry-After"] = Math.ceil(info.retryAfter / 1e3).toString();
+	return headers;
+}
+
+//#endregion
+exports.TooManyRequestsError = TooManyRequestsError;
+exports.checkRateLimit = checkRateLimit;
+exports.defaultKeyGenerator = defaultKeyGenerator;
+exports.getRateLimitHeaders = getRateLimitHeaders;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["message?: string","retryAfter?: number","defaultKeyGenerator: RateLimitKeyGenerator","config: RateLimitConfig<RateLimitData>","ctx: RateLimitContext<TServices, TLogger, TSession>","info: RateLimitInfo","config: RateLimitConfig","headers: RateLimitHeaders"],"sources":["../src/index.ts"],"sourcesContent":["import type { Cache } from '@geekmidas/cache';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service, ServiceRecord } from '@geekmidas/services';\n\n/**\n * Error thrown when rate limit is exceeded\n */\nexport class TooManyRequestsError extends Error {\n  public readonly statusCode = 429;\n  public readonly retryAfter?: number;\n\n  constructor(message?: string, retryAfter?: number) {\n    super(message || 'Too many requests, please try again later.');\n    this.name = 'TooManyRequestsError';\n    this.retryAfter = retryAfter;\n  }\n}\n\n/**\n * Rate limit configuration for an endpoint\n */\nexport interface RateLimitConfig<T = RateLimitData> {\n  /**\n   * Maximum number of requests allowed in the window\n   */\n  limit: number;\n\n  /**\n   * Time window in milliseconds\n   */\n  windowMs: number;\n\n  /**\n   * Cache instance to store rate limit data\n   */\n  cache: Cache<T>;\n\n  /**\n   * Key generator function to identify clients\n   * Defaults to using IP address\n   */\n  keyGenerator?: RateLimitKeyGenerator;\n\n  /**\n   * Skip rate limiting for certain requests\n   */\n  skip?: RateLimitSkipFn;\n\n  /**\n   * Optional message to return when rate limit is exceeded\n   */\n  message?: string;\n\n  /**\n   * Optional custom handler when rate limit is exceeded\n   */\n  handler?: RateLimitExceededHandler;\n\n  /**\n   * Whether to include rate limit headers in response\n   * @default true\n   */\n  standardHeaders?: boolean;\n\n  /**\n   * Whether to include legacy rate limit headers\n   * @default false\n   */\n  legacyHeaders?: boolean;\n}\n\n/**\n * Context for rate limiting decisions\n */\nexport interface RateLimitContext<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> {\n  header: (key: string) => string | undefined;\n  services: ServiceRecord<TServices>;\n  logger: TLogger;\n  session: TSession;\n  path: string;\n  method: string;\n}\n\n/**\n * Function to generate a unique key for rate limiting\n */\nexport type RateLimitKeyGenerator<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> = (\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n) => string | Promise<string>;\n\n/**\n * Function to determine if rate limiting should be skipped\n */\nexport type RateLimitSkipFn<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> = (\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n) => boolean | Promise<boolean>;\n\n/**\n * Handler for when rate limit is exceeded\n */\nexport type RateLimitExceededHandler<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n> = (\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n  info: RateLimitInfo,\n) => void | Promise<void>;\n\n/**\n * Information about current rate limit status\n */\nexport interface RateLimitInfo {\n  /**\n   * Current request count in the window\n   */\n  count: number;\n\n  /**\n   * Maximum allowed requests\n   */\n  limit: number;\n\n  /**\n   * Remaining requests allowed\n   */\n  remaining: number;\n\n  /**\n   * Time when the window resets (Unix timestamp)\n   */\n  resetTime: number;\n\n  /**\n   * Time until reset in milliseconds\n   */\n  retryAfter: number;\n}\n\n/**\n * Headers to be set on responses\n */\nexport interface RateLimitHeaders {\n  'X-RateLimit-Limit'?: string;\n  'X-RateLimit-Remaining'?: string;\n  'X-RateLimit-Reset'?: string;\n  'Retry-After'?: string;\n  'X-RateLimit-Retry-After'?: string;\n  'X-RateLimit-Reset-After'?: string;\n}\n\n/**\n * Data stored in cache for rate limiting\n */\nexport interface RateLimitData {\n  count: number;\n  resetTime: number;\n}\n\n/**\n * Default key generator using IP address\n */\nexport const defaultKeyGenerator: RateLimitKeyGenerator = (ctx) => {\n  // Try various headers for IP address\n  const ip =\n    ctx.header('x-forwarded-for')?.split(',')[0]?.trim() ||\n    ctx.header('x-real-ip') ||\n    ctx.header('x-client-ip') ||\n    ctx.header('cf-connecting-ip') ||\n    'unknown';\n\n  return `rate-limit:${ctx.method}:${ctx.path}:${ip}`;\n};\n\n/**\n * Check rate limit and throw error if exceeded\n */\nexport async function checkRateLimit<\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n>(\n  config: RateLimitConfig<RateLimitData>,\n  ctx: RateLimitContext<TServices, TLogger, TSession>,\n): Promise<RateLimitInfo> {\n  // Check if we should skip rate limiting\n  if (config.skip && (await config.skip(ctx))) {\n    return {\n      count: 0,\n      limit: config.limit,\n      remaining: config.limit,\n      resetTime: Date.now() + config.windowMs,\n      retryAfter: config.windowMs,\n    };\n  }\n\n  // Generate key for this request\n  const keyGenerator = config.keyGenerator || defaultKeyGenerator;\n  const key = await keyGenerator(ctx);\n\n  // Get current data from cache\n  const now = Date.now();\n  let data = await config.cache.get(key);\n\n  // If no data or window expired, create new entry\n  if (!data || data.resetTime <= now) {\n    const resetTime = now + config.windowMs;\n    data = { count: 1, resetTime };\n\n    // Store with TTL matching the window\n    const ttlSeconds = Math.ceil(config.windowMs / 1000);\n    await config.cache.set(key, data, ttlSeconds);\n  } else {\n    // Increment count\n    data.count++;\n\n    // Calculate remaining TTL\n    const remainingMs = data.resetTime - now;\n    const ttlSeconds = Math.ceil(remainingMs / 1000);\n    await config.cache.set(key, data, ttlSeconds);\n  }\n\n  // Calculate rate limit info\n  const info: RateLimitInfo = {\n    count: data.count,\n    limit: config.limit,\n    remaining: Math.max(0, config.limit - data.count),\n    resetTime: data.resetTime,\n    retryAfter: data.resetTime - now,\n  };\n\n  // Check if limit exceeded\n  if (data.count > config.limit) {\n    // Call custom handler if provided\n    if (config.handler) {\n      await config.handler(ctx, info);\n    }\n\n    // Throw rate limit error\n    const retryAfterSeconds = Math.ceil(info.retryAfter / 1000);\n    throw new TooManyRequestsError(\n      config.message || 'Too many requests, please try again later.',\n      retryAfterSeconds,\n    );\n  }\n\n  return info;\n}\n\n/**\n * Generate rate limit headers\n */\nexport function getRateLimitHeaders(\n  info: RateLimitInfo,\n  config: RateLimitConfig,\n): RateLimitHeaders {\n  const headers: RateLimitHeaders = {};\n\n  if (config.standardHeaders !== false) {\n    headers['X-RateLimit-Limit'] = info.limit.toString();\n    headers['X-RateLimit-Remaining'] = info.remaining.toString();\n    headers['X-RateLimit-Reset'] = new Date(info.resetTime).toISOString();\n  }\n\n  if (config.legacyHeaders) {\n    headers['X-RateLimit-Retry-After'] = info.retryAfter.toString();\n    headers['X-RateLimit-Reset-After'] = Math.ceil(\n      info.retryAfter / 1000,\n    ).toString();\n  }\n\n  // Always set Retry-After when limit is exceeded\n  if (info.remaining === 0) {\n    headers['Retry-After'] = Math.ceil(info.retryAfter / 1000).toString();\n  }\n\n  return headers;\n}\n"],"mappings":";;;;;AAOA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,AAAgB,aAAa;CAC7B,AAAgB;CAEhB,YAAYA,SAAkBC,YAAqB;AACjD,QAAM,WAAW,6CAA6C;AAC9D,OAAK,OAAO;AACZ,OAAK,aAAa;CACnB;AACF;;;;AA8JD,MAAaC,sBAA6C,CAAC,QAAQ;CAEjE,MAAM,KACJ,IAAI,OAAO,kBAAkB,EAAE,MAAM,IAAI,CAAC,IAAI,MAAM,IACpD,IAAI,OAAO,YAAY,IACvB,IAAI,OAAO,cAAc,IACzB,IAAI,OAAO,mBAAmB,IAC9B;AAEF,SAAQ,aAAa,IAAI,OAAO,GAAG,IAAI,KAAK,GAAG,GAAG;AACnD;;;;AAKD,eAAsB,eAKpBC,QACAC,KACwB;AAExB,KAAI,OAAO,QAAS,MAAM,OAAO,KAAK,IAAI,CACxC,QAAO;EACL,OAAO;EACP,OAAO,OAAO;EACd,WAAW,OAAO;EAClB,WAAW,KAAK,KAAK,GAAG,OAAO;EAC/B,YAAY,OAAO;CACpB;CAIH,MAAM,eAAe,OAAO,gBAAgB;CAC5C,MAAM,MAAM,MAAM,aAAa,IAAI;CAGnC,MAAM,MAAM,KAAK,KAAK;CACtB,IAAI,OAAO,MAAM,OAAO,MAAM,IAAI,IAAI;AAGtC,MAAK,QAAQ,KAAK,aAAa,KAAK;EAClC,MAAM,YAAY,MAAM,OAAO;AAC/B,SAAO;GAAE,OAAO;GAAG;EAAW;EAG9B,MAAM,aAAa,KAAK,KAAK,OAAO,WAAW,IAAK;AACpD,QAAM,OAAO,MAAM,IAAI,KAAK,MAAM,WAAW;CAC9C,OAAM;AAEL,OAAK;EAGL,MAAM,cAAc,KAAK,YAAY;EACrC,MAAM,aAAa,KAAK,KAAK,cAAc,IAAK;AAChD,QAAM,OAAO,MAAM,IAAI,KAAK,MAAM,WAAW;CAC9C;CAGD,MAAMC,OAAsB;EAC1B,OAAO,KAAK;EACZ,OAAO,OAAO;EACd,WAAW,KAAK,IAAI,GAAG,OAAO,QAAQ,KAAK,MAAM;EACjD,WAAW,KAAK;EAChB,YAAY,KAAK,YAAY;CAC9B;AAGD,KAAI,KAAK,QAAQ,OAAO,OAAO;AAE7B,MAAI,OAAO,QACT,OAAM,OAAO,QAAQ,KAAK,KAAK;EAIjC,MAAM,oBAAoB,KAAK,KAAK,KAAK,aAAa,IAAK;AAC3D,QAAM,IAAI,qBACR,OAAO,WAAW,8CAClB;CAEH;AAED,QAAO;AACR;;;;AAKD,SAAgB,oBACdA,MACAC,QACkB;CAClB,MAAMC,UAA4B,CAAE;AAEpC,KAAI,OAAO,oBAAoB,OAAO;AACpC,UAAQ,uBAAuB,KAAK,MAAM,UAAU;AACpD,UAAQ,2BAA2B,KAAK,UAAU,UAAU;AAC5D,UAAQ,uBAAuB,IAAI,KAAK,KAAK,WAAW,aAAa;CACtE;AAED,KAAI,OAAO,eAAe;AACxB,UAAQ,6BAA6B,KAAK,WAAW,UAAU;AAC/D,UAAQ,6BAA6B,KAAK,KACxC,KAAK,aAAa,IACnB,CAAC,UAAU;CACb;AAGD,KAAI,KAAK,cAAc,EACrB,SAAQ,iBAAiB,KAAK,KAAK,KAAK,aAAa,IAAK,CAAC,UAAU;AAGvE,QAAO;AACR"}