#配置详解

const { RateLimiter } = require('flex-rate-limit');

// 默认配置：1分钟内最多100次请求
const limiter = new RateLimiter({
  windowMs: 60 * 1000,  // 1分钟
  max: 100,             // 最多100次
});

windowMs: 60 * 1000        // 1分钟 = 60秒
windowMs: 15 * 60 * 1000   // 15分钟
windowMs: 60 * 60 * 1000   // 1小时

// 方式1：固定数字
max: 5        // 最多5次
max: 100      // 最多100次

// 方式2：动态函数（根据用户等级）
max: async (req) => {
  if (req.user?.vip) return 1000;  // VIP用户
  return 100;                       // 普通用户
}

algorithm: 'sliding-window'  // 滑动窗口（默认，推荐）
algorithm: 'fixed-window'    // 固定窗口（高并发）
algorithm: 'token-bucket'    // 令牌桶（允许突发）
algorithm: 'leaky-bucket'    // 漏桶（平滑流量）

// 配置：windowMs: 60000 (60秒), max: 100

// 配置：windowMs: 60000 (60秒), max: 100

// 配置：capacity: 100, refillRate: 100 (每秒100个), windowMs: 1000

// 配置：capacity: 100, leakRate: 100 (每秒漏100个), windowMs: 1000

// 方式1：内存存储（默认，单服务器）
store: 'memory'

// 方式2：Redis连接字符串
store: 'redis://localhost:6379'

// 方式3：Redis Store实例（推荐）
const Redis = require('ioredis');
const { RedisStore } = require('flex-rate-limit');

store: new RedisStore({
  client: new Redis({ host: '127.0.0.1', port: 6379 }),
  prefix: 'rl:',
})

// 方式4：CacheHubStore 原子后端
const { CacheHubStore } = require('flex-rate-limit');

store: new CacheHubStore({
  client: new Redis('redis://localhost:6379'),
  prefix: 'rl:',
})

const { keyGenerators } = require('flex-rate-limit');

// 预定义生成器（函数引用）
keyGenerator: keyGenerators.ip            // 按IP限流
keyGenerator: keyGenerators.userId        // 按用户ID限流
keyGenerator: keyGenerators.userAndRoute  // 按用户+路由限流（业务锁）⭐

// 自定义函数
keyGenerator: (req, context) => {
  const userId = req.user?.id || req.ip;
  const route = context?.route || req.path;
  return `user:${userId}:${route}`;
}

const limiter = new RateLimiter({
  // ... 核心配置

  // 跳过特定请求（如健康检查）
  skip: (req) => req.path === '/health',
  
  // 路由级别配置（覆盖全局配置）
  perRoute: {
    '/api/login': { max: 5, windowMs: 15 * 60 * 1000 },
    '/api/query': { max: 200, windowMs: 60 * 1000 },
  },
  
  // 自定义限流响应
  handler: (req, res) => {
    res.status(429).json({ 
      error: '请求过多，请稍后再试',
      retryAfter: 60,
    });
  },
  
  // 是否添加响应头（X-RateLimit-*）
  headers: true,
  
  // 是否跳过成功/失败请求的计数
  skipSuccessfulRequests: false,
  skipFailedRequests: false,
});

const { RateLimiter, keyGenerators } = require('flex-rate-limit');

const limiter = new RateLimiter({
  // 核心配置
  windowMs: 60 * 1000,           // 1分钟
  max: 100,                      // 最多100次
  algorithm: 'sliding-window',   // 滑动窗口
  
  // 存储配置
  store: 'memory',               // 内存存储
  
  // 键生成器（业务锁：用户+路由）
  keyGenerator: (ctx, context) => {
    const userId = ctx.user?.id || ctx.ip;
    return `user:${userId}:${context?.route || ctx.path}`;
  },
  
  // 可选配置
  headers: true,                 // 添加响应头
  skip: (req) => req.path === '/health',  // 跳过健康检查
});

const loginLimiter = new RateLimiter({
  windowMs: 15 * 60 * 1000,  // 15分钟
  max: 5,                     // ⭐ 最多5次（防暴力破解）
  keyGenerator: keyGenerators.ip,         // 按IP限制
  handler: (req, res) => {
    res.status(429).json({
      error: '登录尝试过多，请15分钟后再试',
    });
  },
});

const sensitiveOpLimiter = new RateLimiter({
  windowMs: 60 * 60 * 1000,   // 1小时
  max: 10,                     // ⭐ 最多10次（修改密码、支付等）
  keyGenerator: keyGenerators.userId,      // 按用户限制
});

const mutationLimiter = new RateLimiter({
  windowMs: 60 * 60 * 1000,   // 1小时
  max: 50,                     // ⭐ 最多50次（创建、更新、删除）
  keyGenerator: keyGenerators.userAndRoute, // 按用户+路由限制（业务锁）
});

const queryLimiter = new RateLimiter({
  windowMs: 60 * 1000,        // 1分钟
  max: 100,                    // ⭐ 最多100次（列表、详情查询）
  keyGenerator: keyGenerators.userAndRoute,
});

const publicApiLimiter = new RateLimiter({
  windowMs: 60 * 60 * 1000,   // 1小时
  max: 1000,                   // ⭐ 最多1000次（公开接口）
  keyGenerator: (req) => req.apiKey || req.ip,
});

const tieredLimiter = new RateLimiter({
  windowMs: 60 * 60 * 1000,
  max: async (req) => {
    const tier = req.user?.tier || 'free';
    return {
      free: 100,        // ⭐ 免费用户
      basic: 500,       // ⭐ 基础会员
      premium: 2000,    // ⭐ 高级会员
      enterprise: 10000,// ⭐ 企业用户
    }[tier];
  },
  keyGenerator: keyGenerators.userId,
});

const Redis = require('ioredis');
const { RateLimiter, RedisStore } = require('flex-rate-limit');

const distributedLimiter = new RateLimiter({
  windowMs: 60 * 1000,
  max: 100,
  store: new RedisStore({
    client: new Redis('redis://redis-server:6379'),
    prefix: 'rl:',
  }),
});

const Redis = require('ioredis');
const { RateLimiter, RedisStore } = require('flex-rate-limit');

const redis = new Redis({
  host: 'localhost',
  port: 6379,
  db: 0, // Redis 数据库编号
  password: 'your-password', // 如果需要密码
});

const limiter = new RateLimiter({
  windowMs: 15 * 60 * 1000,
  max: 100,
  store: new RedisStore({
    client: redis,
    prefix: 'rl:', // 键前缀（避免键冲突）
    expiry: 3600, // 数据过期时间（秒）
  }),
});