Maximale Edge-Performance: Cloudflare Workers Tipps [2026]

export interface Env {
  EDGE_CACHE_KV: KVNamespace;
  UPSTREAM_API_URL: string;
}

interface CacheEnvelope<T = unknown> {
  data: T;
  cachedAt: number;
}

/**
 * Isolat-weite Map zur Koaleszenz paralleler identischer Subrequests im selben V8-Isolat.
 * Speichert serialisierte JSON-Strings, um Stream-Lock-Konflikte zu vermeiden.
 */
const inFlightRequests = new Map<string, Promise<string>>();

const KV_EDGE_CACHE_TTL_SECONDS = 120; // Lokale PoP-RAM Haltedauer (min. 60s)
const KV_EXPIRATION_TTL_SECONDS = 900; // Globaler Storage TTL (15 Minuten)
const UPSTREAM_TIMEOUT_MS = 1500;      // Harter Timeout für Origin-Aufrufe

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    if (request.method !== "GET") {
      return new Response("Method Not Allowed", { status: 405 });
    }

    const url = new URL(request.url);
    const cacheKey = `v1:perf:${url.pathname}:${url.searchParams.toString()}`;

    // 1. Fast Path: Lokaler PoP-RAM Lookup (Auslieferung < 2 ms bei Hot Cache)
    const cachedRaw = await env.EDGE_CACHE_KV.get(cacheKey, {
      type: "text",
      cacheTtl: KV_EDGE_CACHE_TTL_SECONDS,
    });

    if (cachedRaw !== null) {
      return new Response(cachedRaw, {
        status: 200,
        headers: {
          "Content-Type": "application/json; charset=utf-8",
          "X-Edge-Cache": "HIT-KV",
          "Cache-Control": "public, max-age=60, s-maxage=120",
        },
      });
    }

    // 2. Deduplizierter Upstream-Fetch mit verknüpftem AbortSignal
    try {
      const payload = await fetchWithDeduplication(cacheKey, async () => {
        const upstreamUrl = new URL(url.pathname + url.search, env.UPSTREAM_API_URL);

        // Verbinde strikten Timeout mit Client-Disconnect
        const timeoutSignal = AbortSignal.timeout(UPSTREAM_TIMEOUT_MS);
        const combinedSignal = AbortSignal.any([timeoutSignal, request.signal]);

        const upstreamResponse = await fetch(upstreamUrl.toString(), {
          method: "GET",
          headers: {
            "Accept": "application/json",
            "User-Agent": "Cloudflare-Worker-Edge-Client/1.0",
          },
          signal: combinedSignal,
          cf: {
            cacheEverything: true,
            cacheTtlByStatus: { "200-299": 60, "404": 10, "500-599": 0 },
          },
        });

        if (!upstreamResponse.ok) {
          throw new Error(`Upstream HTTP ${upstreamResponse.status}`);
        }

        const rawBody = await upstreamResponse.text();
        const envelope: CacheEnvelope = {
          data: JSON.parse(rawBody),
          cachedAt: Date.now(),
        };
        const serialized = JSON.stringify(envelope);

        // 3. Non-Blocking KV-Hydration: Blockiert niemals die Antwortzeit (TTFB)
        ctx.waitUntil(
          env.EDGE_CACHE_KV.put(cacheKey, serialized, {
            expirationTtl: KV_EXPIRATION_TTL_SECONDS,
          }).catch((err) => console.error("KV async write failed:", err))
        );

        return serialized;
      });

      return new Response(payload, {
        status: 200,
        headers: {
          "Content-Type": "application/json; charset=utf-8",
          "X-Edge-Cache": "MISS-COALESCED",
          "Cache-Control": "public, max-age=60, s-maxage=120",
        },
      });
    } catch (error: unknown) {
      const isTimeout =
        error instanceof DOMException &&
        (error.name === "TimeoutError" || error.name === "AbortError");

      return new Response(
        JSON.stringify({
          error: isTimeout ? "Upstream Gateway Timeout" : "Bad Gateway",
          code: isTimeout ? "UPSTREAM_TIMEOUT" : "UPSTREAM_ERROR",
        }),
        {
          status: isTimeout ? 504 : 502,
          headers: { "Content-Type": "application/json; charset=utf-8" },
        }
      );
    }
  },
} satisfies ExportedHandler<Env>;

/**
 * Stellt sicher, dass N parallele Anfragen für denselben Schlüssel im selben Isolat
 * nur genau 1 Upstream-Fetch initiieren.
 */
async function fetchWithDeduplication(
  key: string,
  fetcher: () => Promise<string>
): Promise<string> {
  const existingPromise = inFlightRequests.get(key);
  if (existingPromise) {
    return existingPromise;
  }

  const promise = fetcher().finally(() => {
    inFlightRequests.delete(key);
  });

  inFlightRequests.set(key, promise);
  return promise;
}