防范恶意刷单与 API 滥用：在 Node.js 中基于 Redis Lua 脚本实现的分布式限流锁

import Redis from 'ioredis';

const redis = new Redis({
  host: '127.0.0.1',
  port: 6379,
});

// 定义 Redis 令牌桶 Lua 脚本
// KEYS[1]: 限流的 Key (例如 ratelimit:user_12345:api_checkout)
// ARGV[1]: 桶的最大容量 (Max Capacity)
// ARGV[2]: 令牌填充速率 (Fill Rate, 每秒产生的令牌数)
// ARGV[3]: 当前请求消耗的令牌数 (usually 1)
// ARGV[4]: 当前系统时间戳 (Unix Timestamp in seconds)
const tokenBucketScript = `
  local key = KEYS[1]
  local max_capacity = tonumber(ARGV[1])
  local fill_rate = tonumber(ARGV[2])
  local tokens_to_consume = tonumber(ARGV[3])
  local now = tonumber(ARGV[4])

  -- 获取桶的当前状态
  local data = redis.call('HMGET', key, 'tokens', 'last_updated')
  local tokens = tonumber(data[1])
  local last_updated = tonumber(data[2])

  if not tokens then
    -- 首次请求，初始化桶为满令牌状态
    tokens = max_capacity
    last_updated = now
  else
    -- 计算距离上次更新流逝的时间，并补充相应的令牌
    local elapsed = math.max(0, now - last_updated)
    local generated = elapsed * fill_rate
    tokens = math.min(max_capacity, tokens + generated)
    last_updated = now
  end

  -- 判断令牌是否足够扣减
  if tokens >= tokens_to_consume then
    tokens = tokens - tokens_to_consume
    -- 保存桶最新的状态
    redis.call('HMSET', key, 'tokens', tokens, 'last_updated', last_updated)
    -- 设置 Key 的过期时间，防止冷 Key 占用 Redis 内存
    redis.call('EXPIRE', key, 86400)
    return 1 -- 允许通过
  else
    -- 令牌不足，保存补充后的令牌状态，但不进行扣减
    redis.call('HMSET', key, 'tokens', tokens, 'last_updated', last_updated)
    redis.call('EXPIRE', key, 86400)
    return 0 -- 限流拦截
  end
`;

export async function checkRateLimit(
  key: string,
  maxCapacity: number,
  fillRate: number,
  tokensNeeded: number = 1
): Promise<boolean> {
  const nowInSeconds = Math.floor(Date.now() / 1000);

  try {
    // 使用 EVAL 运行 Lua 脚本，保证执行的原子性
    const result = await redis.eval(
      tokenBucketScript,
      1, // KEYS 数组的长度
      `ratelimit:${key}`,
      maxCapacity.toString(),
      fillRate.toString(),
      tokensNeeded.toString(),
      nowInSeconds.toString()
    );

    return result === 1;
  } catch (error) {
    console.error('Rate limiting Redis execution failed:', error);
    // 降级策略：如果 Redis 崩了，建议放行或者采用本地兜底限流，防止限流器挂掉导致整个业务不可用
    return true;
  }
}

// 示例：在中间件中使用限流器
async function handleCheckoutRequest(userId: string) {
  const isAllowed = await checkRateLimit(`user:${userId}:checkout`, 10, 2); // 桶大小 10，每秒恢复 2 个令牌
  if (isAllowed) {
    console.log(`[Checkout] User ${userId} request processed successfully.`);
  } else {
    console.log(`[Rate Limit] User ${userId} request blocked (Too Many Requests).`);
  }
}

// 模拟连续高并发请求
(async () => {
  for (let i = 0; i < 15; i++) {
    await handleCheckoutRequest('user_999');
    // 模拟极小的时间间隔
    await new Promise((resolve) => setTimeout(resolve, 100));
  }
})();