Caching & Redis

API-Anfrage
    |
    v
Rate-Limit-Middleware (withRateLimit)
    |--- Extrahiert userId (Clerk) und IP (Header)
    |
    v
Ephemeral Cache (In-Memory-Map)
    |--- Treffer? → Gecachtes Ergebnis zurückgeben (kein Redis-Aufruf)
    |--- Kein Treffer? → Weiter zu Redis
    |
    v
Upstash Redis (Sliding-Window-Algorithmus)
    |--- Prüft benutzerbezogenes Limit (wenn userId verfügbar)
    |--- Prüft IP-bezogenes Limit (wenn IP verfügbar)
    |--- Gibt zurück: { success, limit, remaining, reset }
    |
    v
Antwort
    |--- 200 OK + X-RateLimit-*-Header (wenn erlaubt)
    |--- 429 Too Many Requests (wenn Rate Limit überschritten)

const API_LIMITS: Record<
  APICategory,
  { user?: RateLimitConfig; ip?: RateLimitConfig }
> = {
  upload: {
    user: { requests: 10, window: '1 h', identifier: 'user' },
    ip: { requests: 20, window: '1 h', identifier: 'ip' },
  },
  email: {
    user: { requests: 5, window: '1 h', identifier: 'user' },
    ip: { requests: 10, window: '1 h', identifier: 'ip' },
  },
  contact: {
    ip: { requests: 3, window: '1 h', identifier: 'ip' },
  },
  payments: {
    user: { requests: 20, window: '1 h', identifier: 'user' },
  },
  webhooks: {
    ip: { requests: 100, window: '1 h', identifier: 'ip' },
  },
  api: {
    user: { requests: 100, window: '1 h', identifier: 'user' },
    ip: { requests: 200, window: '1 h', identifier: 'ip' },
  },
}

export function withRateLimit(
  category: APICategory,
  handler: (request: NextRequest) => Promise<NextResponse>
): (request: NextRequest) => Promise<NextResponse> {

import { withRateLimit } from '@/lib/security/rate-limit-middleware'

// Handler mit einer Rate-Limit-Kategorie umhüllen
export const POST = withRateLimit('upload', async (request) => {
  // Deine Handler-Logik — wird nur ausgeführt, wenn das Rate Limit nicht überschritten ist
  return NextResponse.json({ success: true })
})

{
  "error": "Rate limit exceeded",
  "message": "Too many requests. Please try again in 45 minutes.",
  "retryAfter": "45 minutes",
  "limit": 10,
  "remaining": 0,
  "reset": 1708012800000
}

// Beispiel: Caching der Pricing-Konfiguration
// Modulübergreifende Variable bleibt über Anfragen in derselben Serverless-Instanz erhalten
let cachedPricingConfig: PricingConfig | null = null
let lastFetched = 0
const CACHE_TTL = 5 * 60 * 1000 // 5 Minuten

export async function getPricingConfig(): Promise<PricingConfig> {
  const now = Date.now()
  if (cachedPricingConfig && now - lastFetched < CACHE_TTL) {
    return cachedPricingConfig
  }

  cachedPricingConfig = await fetchPricingFromDB()
  lastFetched = now
  return cachedPricingConfig
}

Redis verfügbar?
    |
    ├── Ja → Normales Rate Limiting
    |         (Limits prüfen, Erfolg/Fehler zurückgeben)
    |
    └── Nein → Fail-Open-Modus
              |--- Warnung protokollieren: "Rate limiting disabled - Redis not available"
              |--- Erfolg mit maximalen Limits zurückgeben
              |--- Anfrage wird normal verarbeitet