Manage Multiple Limiters (Recommended)

import {
  initRateLimit,
  RateLimitBuilder,
  RegisterConfigParam, // Type for registration config
  slidingWindow,      // Example algorithm
  fixedWindow,
} from 'oss-ratelimit';
 
// Define names for your different limiters (enhances type safety)
export type LimiterName = 'apiGeneral' | 'apiExpensive' | 'loginAttempts';
 
// Create the registry instance
// It's recommended to use environment variables for Redis connection details
export const rateLimiterRegistry: RateLimitBuilder<LimiterName> = initRateLimit<LimiterName>({
  // Default Redis options applied to all limiters unless overridden
  defaultRedisOptions: {
    url: process.env.RATELIMIT_REDIS_URL || 'redis://localhost:6379',
    // password: process.env.RATELIMIT_REDIS_PASSWORD,
    // database: 0, // Default database
  },
});
 
// Define configurations for each named limiter
export const limiterConfigs: Record<LimiterName, RegisterConfigParam> = {
  apiGeneral: {
    limiter: slidingWindow(50, '30 s'), // 50 requests per 30 seconds
    prefix: 'rl_api_gen', // Unique prefix helps organize Redis keys
    analytics: true,      // Enable analytics for this limiter
  },
  apiExpensive: {
    limiter: fixedWindow(5, '1 m'),     // 5 requests per minute
    prefix: 'rl_api_exp',
    timeout: 500,                      // Shorter Redis timeout for this one
  },
  loginAttempts: {
    limiter: fixedWindow(5, '15 m'),    // 5 login attempts per 15 minutes
    prefix: 'rl_login',
    // Example: Using a different Redis DB or instance for sensitive limits
    // envRedisKey: 'LOGIN_REDIS_URL', // Or use 'redis' options:
    // redis: { database: 1 }
  },
};

import { initializeLimiters } from 'oss-ratelimit';
// ... (previous registry setup code) ...
 
// Eagerly initialize all limiters defined in limiterConfigs
// Handle the promise appropriately (e.g., in your server startup logic)
export const initializedLimitersPromise = initializeLimiters({
  registry: rateLimiterRegistry,
  configs: limiterConfigs,
  verbose: process.env.NODE_ENV !== 'production', // Log progress in dev
  throwOnError: true, // Recommended: Stop startup if a limiter fails
});
 
// You can add listeners to the registry *before* initialization
rateLimiterRegistry.on('limiterRegister', ({ name, clientKey }) => {
  console.log(`✅ Limiter "${name}" registered using Redis client: ${clientKey}`);
});
rateLimiterRegistry.on('redisError', ({ clientKey, error }) => {
   console.error(`❌ Redis Error for client ${clientKey}:`, error);
});
rateLimiterRegistry.on('limiterError', ({ name, error }) => {
   console.error(`❌ Failed to initialize limiter "${name}":`, error);
});
 
 
// Handle potential initialization errors globally if needed
initializedLimitersPromise.catch(error => {
   console.error("💥 Critical error during rate limiter initialization:", error);
   // Potentially exit the application or disable features relying on rate limiting
   process.exit(1);
});

import type { NextApiRequest, NextApiResponse } from 'next';
import { rateLimiterRegistry, LimiterName } from '@/lib/ratelimit'; // Adjust path
import { getIpFromRequest } from '@/utils/getIpFromRequest';
 
export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  const ip = getIpFromRequest(req);
  if (!ip) return res.status(400).json({ error: 'Cannot determine IP.' });
 
  try {
    // Get the specific, pre-initialized limiter instance by name
    const limiter = rateLimiterRegistry.get('apiExpensive'); // Throws if not initialized
 
    const { success, remaining } = await limiter.limit(ip);
 
    // Set headers (implementation omitted for brevity)
    // ... set X-RateLimit-* headers ...
 
    if (!success) {
      // ... return 429 ...
      return res.status(429).json({ error: 'Too many requests for expensive route.' });
    }
 
    // --- Proceed with expensive logic ---
    res.status(200).json({ result: 'Expensive operation completed!' });
 
  } catch (error: any) {
    // Handle errors (e.g., if get() throws, or limit() fails)
    console.error("Rate limit error on expensive route:", error);
    return res.status(500).json({ error: 'Internal Server Error' });
  }
}

import { createLimiterAccessor } from 'oss-ratelimit';
// ... (previous registry setup code) ...
 
// Create a type-safe getter function bound to your registry
// Ensure this is called *after* limiters are likely initialized, or handle errors
export const getLimiter = createLimiterAccessor(rateLimiterRegistry);
 
// Usage elsewhere:
// import { getLimiter } from '@/lib/ratelimit';
// const generalApiLimiter = getLimiter('apiGeneral');