Edge Fonksiyonları: Ne Oldukları, Ne Zaman Kullanılmalı, Ne Zaman Kullanılmamalı

// Bu Node.js'de çalışır ama edge'de ÇALIŞMAZ
import fs from "fs";
import { createConnection } from "net";
import { execSync } from "child_process";
 
const file = fs.readFileSync("/etc/hosts"); // ❌ Dosya sistemi yok
const conn = createConnection({ port: 5432 }); // ❌ Ham TCP yok
const result = execSync("ls -la"); // ❌ Alt süreçler yok
process.env.DATABASE_URL; // ⚠️  Mevcut ama statik, dağıtım zamanında ayarlanır

// Bunların hepsi edge'de çalışır
const response = await fetch("https://api.example.com/data");
const url = new URL(request.url);
const headers = new Headers({ "Content-Type": "application/json" });
const encoder = new TextEncoder();
const encoded = encoder.encode("hello");
const hash = await crypto.subtle.digest("SHA-256", encoded);
const id = crypto.randomUUID();
 
// Web Streams API
const stream = new ReadableStream({
  start(controller) {
    controller.enqueue("chunk 1");
    controller.enqueue("chunk 2");
    controller.close();
  },
});
 
// Cache API
const cache = caches.default;
await cache.put(request, response.clone());

// ❌ Bunu edge'de yapmayın
import dayjs from "dayjs";
import * as yup from "yup";
import lodash from "lodash";
 
// ✅ Bunun yerine bunu yapın — yerleşik API'leri kullanın
const date = new Date().toISOString();
const isValid = typeof input === "string" && input.length < 200;
const unique = [...new Set(items)];

// middleware.ts — her istekte edge'de çalışır
import { NextRequest, NextResponse } from "next/server";
 
export const config = {
  matcher: ["/", "/shop/:path*"],
};
 
export function middleware(request: NextRequest) {
  const country = request.geo?.country ?? "US";
  const city = request.geo?.city ?? "Unknown";
  const region = request.geo?.region ?? "Unknown";
 
  // Ülkeye özgü mağazaya yönlendir
  if (request.nextUrl.pathname === "/shop") {
    const storeMap: Record<string, string> = {
      DE: "/shop/eu",
      FR: "/shop/eu",
      GB: "/shop/uk",
      JP: "/shop/jp",
      TR: "/shop/tr",
    };
 
    const storePath = storeMap[country] ?? "/shop/us";
    if (request.nextUrl.pathname !== storePath) {
      return NextResponse.redirect(new URL(storePath, request.url));
    }
  }
 
  // Alt akış kullanımı için coğrafi başlıklar ekle
  const response = NextResponse.next();
  response.headers.set("x-user-country", country);
  response.headers.set("x-user-city", city);
  response.headers.set("x-user-region", region);
  return response;
}

import { NextRequest, NextResponse } from "next/server";
 
export function middleware(request: NextRequest) {
  // Kullanıcının zaten bir varyant ataması var mı kontrol et
  const existingVariant = request.cookies.get("ab-variant")?.value;
 
  if (existingVariant) {
    // Doğru varyant sayfasına yeniden yaz
    const url = request.nextUrl.clone();
    url.pathname = `/variants/${existingVariant}${url.pathname}`;
    return NextResponse.rewrite(url);
  }
 
  // Yeni bir varyant ata (50/50 bölünme)
  const variant = Math.random() < 0.5 ? "control" : "treatment";
 
  const url = request.nextUrl.clone();
  url.pathname = `/variants/${variant}${url.pathname}`;
 
  const response = NextResponse.rewrite(url);
  response.cookies.set("ab-variant", variant, {
    maxAge: 60 * 60 * 24 * 30, // 30 gün
    httpOnly: true,
    sameSite: "lax",
  });
 
  return response;
}

import { jwtVerify, importSPKI } from "jose";
import { NextRequest, NextResponse } from "next/server";
 
const PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
-----END PUBLIC KEY-----`;
 
export async function middleware(request: NextRequest) {
  const token = request.cookies.get("session-token")?.value;
 
  if (!token) {
    return NextResponse.redirect(new URL("/login", request.url));
  }
 
  try {
    const key = await importSPKI(PUBLIC_KEY, "RS256");
    const { payload } = await jwtVerify(token, key, {
      algorithms: ["RS256"],
      issuer: "https://auth.example.com",
    });
 
    // Kullanıcı bilgilerini güvenilir başlıklar olarak alt akışa ilet
    const response = NextResponse.next();
    response.headers.set("x-user-id", payload.sub as string);
    response.headers.set("x-user-role", payload.role as string);
    return response;
  } catch {
    // Token süresi dolmuş veya geçersiz
    const response = NextResponse.redirect(new URL("/login", request.url));
    response.cookies.delete("session-token");
    return response;
  }
}

import { NextRequest, NextResponse } from "next/server";
 
// Basit bellek-içi hız sınırlayıcı (edge konumu başına)
const rateLimitMap = new Map<string, { count: number; timestamp: number }>();
 
export function middleware(request: NextRequest) {
  const ip = request.headers.get("x-forwarded-for")?.split(",").pop()?.trim() ?? "unknown";
  const ua = request.headers.get("user-agent") ?? "";
 
  // Bilinen kötü botları engelle
  const badBots = ["AhrefsBot", "SemrushBot", "MJ12bot", "DotBot"];
  if (badBots.some((bot) => ua.includes(bot))) {
    return new NextResponse("Forbidden", { status: 403 });
  }
 
  // Basit hız sınırlama
  const now = Date.now();
  const windowMs = 60_000; // 1 dakika
  const maxRequests = 100;
 
  const entry = rateLimitMap.get(ip);
  if (entry && now - entry.timestamp < windowMs) {
    entry.count++;
    if (entry.count > maxRequests) {
      return new NextResponse("Too Many Requests", {
        status: 429,
        headers: { "Retry-After": "60" },
      });
    }
  } else {
    rateLimitMap.set(ip, { count: 1, timestamp: now });
  }
 
  // Bellek sızıntısını önlemek için periyodik temizlik
  if (rateLimitMap.size > 10_000) {
    const cutoff = now - windowMs;
    for (const [key, val] of rateLimitMap) {
      if (val.timestamp < cutoff) rateLimitMap.delete(key);
    }
  }
 
  return NextResponse.next();
}

import { NextRequest, NextResponse } from "next/server";
 
export function middleware(request: NextRequest) {
  const response = NextResponse.next();
  const url = request.nextUrl;
 
  // Cihaz tabanlı içerik müzakeresi
  const ua = request.headers.get("user-agent") ?? "";
  const isMobile = /mobile|android|iphone/i.test(ua);
  response.headers.set("x-device-type", isMobile ? "mobile" : "desktop");
 
  // Çerezden özellik bayrakları
  const flags = request.cookies.get("feature-flags")?.value;
  if (flags) {
    response.headers.set("x-feature-flags", flags);
  }
 
  // i18n için dil tespiti
  const acceptLanguage = request.headers.get("accept-language") ?? "en";
  const preferredLocale = acceptLanguage.split(",")[0]?.split("-")[0] ?? "en";
  const supportedLocales = [
    "en",
    "tr",
    "de",
    "fr",
    "es",
    "pt",
    "ja",
    "ko",
    "it",
    "nl",
    "ru",
    "pl",
    "uk",
    "sv",
    "cs",
    "ar",
    "hi",
    "zh",
  ];
  const locale = supportedLocales.includes(preferredLocale) ? preferredLocale : "en";
 
  if (!url.pathname.startsWith(`/${locale}`) && !url.pathname.startsWith("/api")) {
    return NextResponse.redirect(new URL(`/${locale}${url.pathname}`, request.url));
  }
 
  return response;
}

// ❌ Bu kalıp temelden edge'de çalışmaz
import { Pool } from "pg";
 
const pool = new Pool({
  connectionString: process.env.DATABASE_URL,
  max: 10, // 10'luk bağlantı havuzu
});
 
// Her edge çağrısı:
// 1. Yeni bir Pool oluşturur (çağrılar arasında güvenilir şekilde yeniden kullanılamaz)
// 2. Veritabanınıza TCP bağlantısı açar (us-east-1'de, edge'de değil)
// 3. Veritabanıyla TLS el sıkışması yapar
// 4. Sorguyu çalıştırır
// 5. İzolat geri dönüştürüldüğünde bağlantıyı atar
//
// PgBouncer gibi bağlantı havuzu servisleriyle bile,
// edge → kaynak veritabanı ağ gecikmesini ödüyorsunuz

// ✅ Bu edge'de çalışır (HTTP tabanlı veritabanı erişimi)
// Ama veritabanı edge düğümünden uzaksa yine de yavaş
import { neon } from "@neondatabase/serverless";
 
export const runtime = "edge";
 
export async function GET(request: Request) {
  const sql = neon(process.env.DATABASE_URL!);
  // Bu, Neon veritabanınıza bir HTTP isteği yapar
  // Çalışır, ama gecikme veritabanı bölgesine olan mesafeye bağlı
  const posts = await sql`SELECT * FROM posts WHERE published = true LIMIT 10`;
  return Response.json(posts);
}

// ❌ Bunlar edge'de CPU süresi limitlerini aşar
export const runtime = "edge";
 
export async function POST(request: Request) {
  const data = await request.json();
 
  // Görüntü işleme — CPU yoğun
  // (Ayrıca sharp kullanamaz çünkü yerel bir modül)
  const processed = heavyImageProcessing(data.image);
 
  // PDF oluşturma — CPU yoğun + Node.js API'leri gerektirir
  const pdf = generatePDF(data.content);
 
  // Büyük veri dönüşümü
  const result = data.items // 100.000 öğe
    .map(transform)
    .filter(validate)
    .sort(compare)
    .reduce(aggregate, {});
 
  return Response.json(result);
}

// ❌ Bu paketler edge'de çalışmaz
import bcrypt from "bcrypt"; // Yerel C++ bağlaması
import sharp from "sharp"; // Yerel C++ bağlaması
import puppeteer from "puppeteer"; // Dosya sistemi + child_process gerektirir
import nodemailer from "nodemailer"; // net modülü gerektirir
import { readFile } from "fs/promises"; // Node.js dosya sistemi API'si
import mongoose from "mongoose"; // TCP bağlantıları + Node.js API'leri
 
// ✅ Edge uyumlu alternatifler
import { hashSync } from "bcryptjs"; // Saf JS implementasyonu (daha yavaş)
// Görüntüler için: ayrı bir servis veya API kullanın
// E-posta için: HTTP tabanlı e-posta API'si kullanın (Resend, SendGrid REST)
// Veritabanı için: HTTP tabanlı istemciler kullanın

// ❌ Barrel dosya importları çok fazla şey çekebilir
import { validateEmail } from "@/lib/utils";
// utils.ts 20 başka modülden yeniden dışa aktarım yapıyorsa, hepsi bundle'lanır
 
// ✅ Doğrudan kaynaktan import edin
import { validateEmail } from "@/lib/validators/email";

// middleware.ts — her zaman edge'de çalışır, opt-in gerekmez
import { NextRequest, NextResponse } from "next/server";
 
export function middleware(request: NextRequest) {
  // Bu, eşleşen her istekten önce çalışır
  // Hızlı tutun — veritabanı çağrıları yok, ağır hesaplama yok
  return NextResponse.next();
}
 
export const config = {
  // Yalnızca belirli yollarda çalıştır
  matcher: ["/((?!_next/static|_next/image|favicon.ico|robots.txt|sitemap.xml).*)"],
};

// app/api/hello/route.ts
export const runtime = "edge"; // Bu tek satır runtime'u değiştirir
 
export async function GET(request: Request) {
  return Response.json({
    message: "Hello from the edge",
    region: process.env.VERCEL_REGION ?? "unknown",
    timestamp: Date.now(),
  });
}

// app/dashboard/page.tsx
export const runtime = "edge";
 
export default async function DashboardPage() {
  // Unutmayın: burada Node.js API'leri yok
  // Herhangi bir veri çekme fetch() veya edge uyumlu istemciler kullanmalı
  const data = await fetch("https://api.example.com/dashboard", {
    headers: { Authorization: `Bearer ${process.env.API_KEY}` },
    next: { revalidate: 60 },
  }).then((r) => r.json());
 
  return (
    <main>
      <h1>Dashboard</h1>
      {/* veriyi render et */}
    </main>
  );
}

// ✅ Edge'de mevcut
fetch(); // HTTP istekleri
Request / Response; // Web standart istek/yanıt
Headers; // HTTP başlıkları
URL / URLSearchParams; // URL ayrıştırma
TextEncoder / TextDecoder; // String kodlama
crypto.subtle; // Kripto işlemleri (imzalama, hashleme)
crypto.randomUUID(); // UUID oluşturma
crypto.getRandomValues(); // Kriptografik rastgele sayılar
structuredClone(); // Derin klonlama
atob() / btoa(); // Base64 kodlama/çözme
setTimeout() / setInterval(); // Zamanlayıcılar (ama CPU limitlerini unutmayın)
console.log(); // Loglama
ReadableStream / WritableStream; // Streaming
AbortController / AbortSignal; // İstek iptali
URLPattern; // URL kalıp eşleme
 
// ❌ Edge'de mevcut DEĞİL
require(); // CommonJS (import kullanın)
fs / path / os; // Node.js yerleşik modülleri
process.exit(); // Süreç kontrolü
Buffer; // Bunun yerine Uint8Array kullanın
__dirname / __filename; // import.meta.url kullanın
setImmediate(); // Web standardı değil

// lib/edge-auth.ts — Edge uyumlu auth yardımcıları
import { jwtVerify, SignJWT, importSPKI, importPKCS8 } from "jose";
 
const PUBLIC_KEY_PEM = process.env.JWT_PUBLIC_KEY!;
const ISSUER = "https://auth.myapp.com";
const AUDIENCE = "https://myapp.com";
 
export interface TokenPayload {
  sub: string;
  email: string;
  role: "user" | "admin" | "moderator";
  iat: number;
  exp: number;
}
 
export async function verifyToken(token: string): Promise<TokenPayload | null> {
  try {
    const publicKey = await importSPKI(PUBLIC_KEY_PEM, "RS256");
    const { payload } = await jwtVerify(token, publicKey, {
      algorithms: ["RS256"],
      issuer: ISSUER,
      audience: AUDIENCE,
      clockTolerance: 30, // 30 saniyelik saat sapma toleransı
    });
 
    return payload as unknown as TokenPayload;
  } catch {
    return null;
  }
}
 
export function isTokenExpiringSoon(payload: TokenPayload): boolean {
  const now = Math.floor(Date.now() / 1000);
  const fiveMinutes = 5 * 60;
  return payload.exp - now < fiveMinutes;
}

// middleware.ts — Auth middleware'i
import { NextRequest, NextResponse } from "next/server";
import { verifyToken, isTokenExpiringSoon } from "./lib/edge-auth";
 
const PUBLIC_PATHS = ["/", "/login", "/register", "/api/auth/login"];
const ADMIN_PATHS = ["/admin"];
 
export async function middleware(request: NextRequest) {
  const { pathname } = request.nextUrl;
 
  // Genel yollar için auth'u atla
  if (PUBLIC_PATHS.some((p) => pathname === p || pathname.startsWith("/api/public"))) {
    return NextResponse.next();
  }
 
  // Token'ı çıkar
  const token = request.cookies.get("auth-token")?.value;
  if (!token) {
    return NextResponse.redirect(new URL("/login", request.url));
  }
 
  // Token'ı doğrula (saf kripto — veritabanı çağrısı yok)
  const payload = await verifyToken(token);
  if (!payload) {
    const response = NextResponse.redirect(new URL("/login", request.url));
    response.cookies.delete("auth-token");
    return response;
  }
 
  // Rol tabanlı erişim kontrolü
  if (ADMIN_PATHS.some((p) => pathname.startsWith(p)) && payload.role !== "admin") {
    return NextResponse.redirect(new URL("/unauthorized", request.url));
  }
 
  // Doğrulanmış kullanıcı bilgilerini güvenilir başlıklar olarak kaynağa ilet
  const response = NextResponse.next();
  response.headers.set("x-user-id", payload.sub);
  response.headers.set("x-user-email", payload.email);
  response.headers.set("x-user-role", payload.role);
 
  // Token yenilenmesi gerekiyorsa sinyal ver
  if (isTokenExpiringSoon(payload)) {
    response.headers.set("x-token-refresh", "true");
  }
 
  return response;
}

// app/api/profile/route.ts — Kaynak sunucu güvenilir başlıkları okur
export async function GET(request: Request) {
  // Bu başlıklar, JWT doğrulamasından sonra edge middleware tarafından ayarlandı
  // Güvenilirler çünkü kendi altyapımızdan geliyorlar
  const userId = request.headers.get("x-user-id");
  const userRole = request.headers.get("x-user-role");
 
  if (!userId) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  // Artık veritabanına erişebiliriz — kaynak sunucudayız,
  // veritabanının hemen yanındayız, bağlantı havuzuyla
  const user = await db.user.findUnique({ where: { id: userId } });
 
  return Response.json(user);
}

// app/api/products/route.ts
export const runtime = "edge";
 
export async function GET(request: Request) {
  const url = new URL(request.url);
  const category = url.searchParams.get("category") ?? "all";
 
  const products = await fetch(`${process.env.ORIGIN_API}/products?category=${category}`).then((r) => r.json());
 
  return Response.json(products, {
    headers: {
      // CDN'de 60 saniye önbelleğe al
      // Yeniden doğrulama sırasında 5 dakikaya kadar eski sunma
      // İstemci 10 saniye önbelleğe alabilir
      "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300, max-age=10",
 
      // Bu başlıklara göre değiştir, farklı varyantlar farklı önbellek girdileri alsın
      Vary: "Accept-Language, Accept-Encoding",
 
      // Hedefli geçersiz kılma için CDN'ye özgü önbellek etiketi
      "Cache-Tag": `products,category-${category}`,
    },
  });
}

import { get } from "@vercel/edge-config";
import { NextRequest, NextResponse } from "next/server";
 
export async function middleware(request: NextRequest) {
  // Edge Config okumaları son derece hızlıdır (~1ms) çünkü
  // veri her edge konumuna çoğaltılmıştır
  const maintenanceMode = await get<boolean>("maintenance_mode");
 
  if (maintenanceMode) {
    return NextResponse.rewrite(new URL("/maintenance", request.url));
  }
 
  // Özellik bayrakları
  const features = await get<Record<string, boolean>>("feature_flags");
  if (features?.["new_pricing_page"] && request.nextUrl.pathname === "/pricing") {
    return NextResponse.rewrite(new URL("/pricing-v2", request.url));
  }
 
  // Dinamik yönlendirmeler (yeniden dağıtım olmadan yönlendirmeleri güncelle)
  const redirects = await get<Array<{ from: string; to: string; permanent: boolean }>>("redirects");
 
  if (redirects) {
    const match = redirects.find((r) => r.from === request.nextUrl.pathname);
    if (match) {
      return NextResponse.redirect(new URL(match.to, request.url), match.permanent ? 308 : 307);
    }
  }
 
  return NextResponse.next();
}

// ✅ Edge için MÜKEMMEL
// - Middleware (auth, yönlendirmeler, yeniden yazmalar, başlıklar)
// - Coğrafi konum mantığı
// - A/B test ataması
// - Bot tespiti / WAF kuralları
// - Önbellek dostu API yanıtları
// - Özellik bayrak kontrolleri
// - CORS preflight yanıtları
// - Statik veri dönüşümleri (VT yok)
// - Webhook imza doğrulaması
 
// ❌ Node.js bölgeselde TUTUN
// - Veritabanı CRUD işlemleri
// - Dosya yüklemeleri / işleme
// - Görüntü manipülasyonu
// - PDF oluşturma
// - E-posta gönderme (HTTP API kullanın, ama yine de bölgesel)
// - WebSocket sunucuları
// - Arka plan işleri / kuyruklar
// - Yerel npm paketleri kullanan her şey
// - Veritabanı sorgulu SSR sayfaları
// - Veritabanına ulaşan GraphQL çözücüler
 
// 🤔 DURUMA BAĞLI
// - Kimlik doğrulama (JWT için edge, oturum-VT için bölgesel)
// - API rotaları (VT yoksa edge, VT varsa bölgesel)
// - Sunucu render sayfaları (veri önbellek/fetch'ten geliyorsa edge, VT'den geliyorsa bölgesel)
// - Gerçek zamanlı özellikler (ilk auth için edge, kalıcı bağlantılar için bölgesel)