Next.js Edge Functions for Global Performance

// middleware.ts
import { NextResponse } from "next/server";
import type { NextRequest } from "next/server";

export function middleware(request: NextRequest) {
  const country = request.geo?.country || "US";
  const response = NextResponse.next();

  // Set geo header for downstream components
  response.headers.set("x-user-country", country);

  // Redirect to country-specific store
  if (request.nextUrl.pathname === "/shop") {
    const storeMap: Record<string, string> = {
      DE: "/shop/eu",
      FR: "/shop/eu",
      GB: "/shop/uk",
      JP: "/shop/asia",
    };
    const targetPath = storeMap[country];
    if (targetPath) {
      return NextResponse.redirect(new URL(targetPath, request.url));
    }
  }

  return response;
}

export const config = {
  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
};

// app/api/feature-flags/route.ts
import { NextRequest, NextResponse } from "next/server";

export const runtime = "edge";

const flags: Record<string, { enabled: boolean; rollout: number }> = {
  new_checkout: { enabled: true, rollout: 0.25 },
  dark_mode: { enabled: true, rollout: 1.0 },
  ai_search: { enabled: false, rollout: 0 },
};

export async function GET(request: NextRequest) {
  const userId = request.headers.get("x-user-id") || "anonymous";

  const userFlags = Object.fromEntries(
    Object.entries(flags).map(([key, config]) => {
      if (!config.enabled) return [key, false];
      const hash = simpleHash(userId + key);
      return [key, hash < config.rollout];
    })
  );

  return NextResponse.json(userFlags, {
    headers: {
      "Cache-Control": "public, s-maxage=60, stale-while-revalidate=300",
    },
  });
}

function simpleHash(str: string): number {
  let hash = 0;
  for (let i = 0; i < str.length; i++) {
    hash = (hash << 5) - hash + str.charCodeAt(i);
    hash |= 0;
  }
  return Math.abs(hash) / 2147483647;
}

// middleware.ts (A/B testing section)
function handleABTest(request: NextRequest): NextResponse {
  const experiment = "pricing-page-v2";
  const cookieName = `ab-${experiment}`;

  let variant = request.cookies.get(cookieName)?.value;

  if (!variant) {
    variant = Math.random() < 0.5 ? "control" : "treatment";
  }

  const url = request.nextUrl.clone();
  if (url.pathname === "/pricing" && variant === "treatment") {
    url.pathname = "/pricing-v2";
  }

  const response = NextResponse.rewrite(url);
  response.cookies.set(cookieName, variant, {
    maxAge: 60 * 60 * 24 * 30,
    httpOnly: true,
    sameSite: "lax",
  });

  return response;
}

// lib/edge-auth.ts
export async function verifyToken(token: string): Promise<boolean> {
  try {
    const [headerB64, payloadB64, signatureB64] = token.split(".");
    const data = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
    const signature = base64UrlDecode(signatureB64);

    const key = await crypto.subtle.importKey(
      "jwk",
      PUBLIC_JWK,
      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
      false,
      ["verify"]
    );

    const valid = await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key, signature, data);
    if (!valid) return false;

    const payload = JSON.parse(atob(payloadB64));
    return payload.exp > Date.now() / 1000;
  } catch {
    return false;
  }
}

export function middleware(request: NextRequest) {
  const start = Date.now();
  const response = NextResponse.next();
  response.headers.set("x-edge-latency", `${Date.now() - start}ms`);
  response.headers.set("x-edge-region", process.env.VERCEL_REGION || "unknown");
  return response;
}