Rate Limiting Implementation

# Rate Limiting Implementation for Google Antigravity

Master rate limiting strategies in Google Antigravity IDE.

## Sliding Window Algorithm

```typescript
import { Redis } from "ioredis";
const redis = new Redis(process.env.REDIS_URL);

export async function slidingWindowRateLimit(
  identifier: string,
  limit: number,
  windowMs: number
) {
  const key = `ratelimit:${identifier}`;
  const now = Date.now();

  const pipeline = redis.pipeline();
  pipeline.zremrangebyscore(key, 0, now - windowMs);
  pipeline.zcard(key);
  pipeline.zadd(key, now, `${now}:${Math.random()}`);
  pipeline.pexpire(key, windowMs);

  const results = await pipeline.exec();
  const count = results![1][1] as number;

  return {
    allowed: count < limit,
    remaining: Math.max(0, limit - count - 1)
  };
}
```

## Middleware

```typescript
import { NextRequest, NextResponse } from "next/server";

export async function rateLimitMiddleware(request: NextRequest) {
  const identifier = request.ip || "unknown";
  const result = await slidingWindowRateLimit(identifier, 100, 60000);
  
  if (!result.allowed) {
    return NextResponse.json({ error: "Too many requests" }, { status: 429 });
  }

  return NextResponse.next();
}
```

## Best Practices

1. **Use Redis** - Distributed rate limiting
2. **Return headers** - Inform clients of limits

Google Antigravity IDE provides rate limiting scaffolding.