Rate Limiting

HTTP/1.1 200 OK
X-RateLimit-Limit: 20
X-RateLimit-Remaining: 15
X-RateLimit-Reset: 1640995200000
X-RateLimit-Bucket: channel:message:create::123456789

{
  "code": "RATE_LIMITED",
  "message": "You are being rate limited",
  "retry_after": 3.5,
  "global": false
}

import { RateLimitService } from '@fluxer/rate_limit';
import { InMemoryCacheService } from '@fluxer/rate_limit';

// Create cache service
const cacheService = new InMemoryCacheService();

// Create rate limit service
const rateLimitService = new RateLimitService(cacheService, {
  globalWindowMs: 1000 // Global window: 1 second
});

// Check a rate limit
const result = await rateLimitService.checkLimit({
  identifier: 'user:123456',
  maxAttempts: 20,
  windowMs: 10000 // 10 seconds
});

if (!result.allowed) {
  console.log(`Rate limited. Retry after ${result.retryAfterMs}ms`);
}

// Check bucket-specific limit
const result = await rateLimitService.checkBucketLimit(
  'channel:message:create::123456',
  {
    limit: 20,
    windowMs: 10000
  }
);

// Check global limit (applies across all endpoints)
const result = await rateLimitService.checkGlobalLimit(
  'user:123456',
  50 // 50 requests per second
);

// Reset rate limit for an identifier (admin only)
await rateLimitService.resetLimit('user:123456');

import { ms } from 'itty-time';

export const ChannelRateLimitConfigs = {
  CHANNEL_MESSAGE_CREATE: {
    bucket: 'channel:message:create::channel_id',
    config: { 
      limit: 20, 
      windowMs: ms('10 seconds') 
    }
  },
  
  CHANNEL_MESSAGE_DELETE: {
    bucket: 'channel:message:delete::channel_id',
    config: { 
      limit: 20, 
      windowMs: ms('10 seconds') 
    }
  }
} as const;

import { rateLimitMiddleware } from '@fluxer/api';
import { ChannelRateLimitConfigs } from '@fluxer/api/rate_limit_configs';

app.post(
  '/channels/:channelId/messages',
  rateLimitMiddleware(ChannelRateLimitConfigs.CHANNEL_MESSAGE_CREATE),
  async (c) => {
    // Handle message creation
  }
);

async function sendMessageWithRetry(
  channelId: string,
  content: string,
  maxRetries = 3
) {
  let retries = 0;
  
  while (retries < maxRetries) {
    try {
      return await sendMessage(channelId, content);
    } catch (error) {
      if (error.code === 'RATE_LIMITED') {
        const delay = error.retry_after * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
        retries++;
      } else {
        throw error;
      }
    }
  }
  
  throw new Error('Max retries exceeded');
}

class RateLimitedQueue {
  private queue: Array<() => Promise<void>> = [];
  private processing = false;
  
  async add(fn: () => Promise<void>) {
    this.queue.push(fn);
    if (!this.processing) {
      await this.process();
    }
  }
  
  private async process() {
    this.processing = true;
    
    while (this.queue.length > 0) {
      const fn = this.queue.shift()!;
      try {
        await fn();
      } catch (error) {
        if (error.code === 'RATE_LIMITED') {
          // Re-queue and wait
          this.queue.unshift(fn);
          await new Promise(resolve => 
            setTimeout(resolve, error.retry_after * 1000)
          );
        }
      }
    }
    
    this.processing = false;
  }
}

// Global limit: 50 requests per second across all endpoints
const result = await rateLimitService.checkGlobalLimit(
  'user:123456',
  50
);

{
  "code": "SLOWMODE_RATE_LIMITED",
  "message": "You are sending messages too quickly",
  "retry_after": 5.0
}

interface RateLimitServiceOptions {
  globalWindowMs?: number;      // Global window duration (default: 1000ms)
  getCurrentTimeMs?: () => number; // Custom time source
}

import { InMemoryCacheService } from '@fluxer/rate_limit';

const cache = new InMemoryCacheService();

import { RedisCacheService } from '@fluxer/cache';

const cache = new RedisCacheService({
  host: 'localhost',
  port: 6379
});