// app/api/posts/route.ts — Serverless Function (default)
import { NextRequest } from "next/server";
import { db } from "@/lib/db";

export async function GET(request: NextRequest) {
  const posts = await db.post.findMany({
    where: { status: "PUBLISHED" },
    orderBy: { createdAt: "desc" },
    take: 20,
  });

  return Response.json({ data: posts });
}

// Force edge runtime
export const runtime = "edge";

// Configure timeout and region
export const maxDuration = 30; // seconds (Pro plan: up to 300s)

// vercel.json (or next.config.ts)
{
  "functions": {
    "app/api/heavy-processing/route.ts": {
      "maxDuration": 60,        // seconds
      "memory": 1024            // MB
    }
  }
}

// app/actions/posts.ts
"use server";

import { db } from "@/lib/db";
import { revalidatePath } from "next/cache";
import { auth } from "@/auth";

export async function createPost(formData: FormData) {
  const session = await auth();
  if (!session) throw new Error("Unauthorized");

  const title = formData.get("title") as string;
  const content = formData.get("content") as string;

  const post = await db.post.create({
    data: { title, content, authorId: session.user.id },
  });

  revalidatePath("/posts");
  return post;
}

// worker.ts (Cloudflare Worker)
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    if (url.pathname === "/api/posts") {
      // D1 is Cloudflare's SQLite-at-the-edge database
      const posts = await env.DB.prepare(
        "SELECT id, title, created_at FROM posts WHERE status = ? ORDER BY created_at DESC LIMIT 20"
      )
        .bind("published")
        .all();

      return Response.json({ data: posts.results });
    }

    if (url.pathname.startsWith("/api/cache/")) {
      // KV is global key-value storage
      const key = url.pathname.replace("/api/cache/", "");
      const value = await env.KV.get(key);

      if (value) return Response.json({ data: JSON.parse(value) });
      return Response.json({ error: "Not found" }, { status: 404 });
    }

    return new Response("Not found", { status: 404 });
  },
};

interface Env {
  DB: D1Database;
  KV: KVNamespace;
  R2: R2Bucket;
}

// handler.ts (AWS Lambda)
import type { APIGatewayProxyHandlerV2 } from "aws-lambda";

export const handler: APIGatewayProxyHandlerV2 = async (event) => {
  const { httpMethod, pathParameters, body, queryStringParameters } = event;

  if (httpMethod === "GET" && pathParameters?.id) {
    const post = await getPost(pathParameters.id);
    return {
      statusCode: 200,
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ data: post }),
    };
  }

  if (httpMethod === "POST") {
    const data = JSON.parse(body ?? "{}");
    const post = await createPost(data);
    return {
      statusCode: 201,
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ data: post }),
    };
  }

  return { statusCode: 404, body: "Not found" };
};

// 1. Lazy imports — only load heavy modules when needed
export async function handler(event: Event) {
  // Don't import at top level if not always needed
  if (event.type === "image-processing") {
    const sharp = await import("sharp");
    return sharp.default(event.body).resize(800).toBuffer();
  }
  // Light path — no heavy imports
  return { statusCode: 200, body: "OK" };
}

// 2. Initialize outside the handler (reused across warm invocations)
// This runs once per container, not per invocation
const prisma = new PrismaClient();
const redis = new Redis(process.env.REDIS_URL);

export async function handler(event: Event) {
  // prisma and redis are already initialized on warm starts
  const user = await prisma.user.findUnique({ where: { id: event.userId } });
  return user;
}

# serverless.yml / SAM template
functions:
  api:
    handler: handler.main
    provisionedConcurrency: 5  # 5 warm instances always ready

// app/api/stream/route.ts (Next.js streaming)
export async function GET() {
  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      // Stream data chunks
      for (let i = 0; i < 10; i++) {
        const data = JSON.stringify({ chunk: i, timestamp: Date.now() });
        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
        await new Promise((resolve) => setTimeout(resolve, 500));
      }
      controller.close();
    },
  });

  return new Response(stream, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
    },
  });
}

// AI response streaming (e.g., with OpenAI / Anthropic)
export async function POST(request: Request) {
  const { messages } = await request.json();

  const response = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": process.env.ANTHROPIC_API_KEY!,
      "anthropic-version": "2023-06-01",
    },
    body: JSON.stringify({
      model: "claude-sonnet-4-20250514",
      max_tokens: 1024,
      stream: true,
      messages,
    }),
  });

  // Forward the stream directly to the client
  return new Response(response.body, {
    headers: {
      "Content-Type": "text/event-stream",
      "Cache-Control": "no-cache",
    },
  });
}

// Neon serverless driver (no persistent connections)
import { neon } from "@neondatabase/serverless";

const sql = neon(process.env.DATABASE_URL!);

export async function GET() {
  const posts = await sql`
    SELECT id, title, created_at
    FROM posts
    WHERE status = 'published'
    ORDER BY created_at DESC
    LIMIT 20
  `;
  return Response.json({ data: posts });
}

// Prisma with connection string for serverless
// prisma/schema.prisma
datasource db {
  provider  = "postgresql"
  url       = env("DATABASE_URL")
  directUrl = env("DIRECT_DATABASE_URL") // For migrations (bypasses pooler)
}

// Connection string with pooler
// DATABASE_URL="postgresql://user:pass@host:6543/db?pgbouncer=true&connection_limit=1"
// DIRECT_DATABASE_URL="postgresql://user:pass@host:5432/db"

// app/api/upload/route.ts — Generate presigned upload URL
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
import { randomUUID } from "crypto";

const s3 = new S3Client({
  region: process.env.AWS_REGION,
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
  },
});

export async function POST(request: Request) {
  const session = await requireAuth();
  const { filename, contentType } = await request.json();

  // Validate file type
  const allowedTypes = ["image/jpeg", "image/png", "image/webp", "application/pdf"];
  if (!allowedTypes.includes(contentType)) {
    return Response.json({ error: "Invalid file type" }, { status: 400 });
  }

  const key = `uploads/${session.user.id}/${randomUUID()}-${filename}`;

  const command = new PutObjectCommand({
    Bucket: process.env.S3_BUCKET!,
    Key: key,
    ContentType: contentType,
    ContentLength: undefined,
    Metadata: { userId: session.user.id },
  });

  const uploadUrl = await getSignedUrl(s3, command, { expiresIn: 300 }); // 5 minutes

  return Response.json({
    uploadUrl,
    key,
    publicUrl: `${process.env.CDN_URL}/${key}`,
  });
}

// Client-side upload
async function uploadFile(file: File) {
  // 1. Get presigned URL
  const { uploadUrl, publicUrl } = await fetch("/api/upload", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      filename: file.name,
      contentType: file.type,
    }),
  }).then((r) => r.json());

  // 2. Upload directly to S3
  await fetch(uploadUrl, {
    method: "PUT",
    headers: { "Content-Type": file.type },
    body: file,
  });

  return publicUrl;
}

# Vercel
vercel env add DATABASE_URL production
vercel env add REDIS_URL production

# AWS Lambda (via SSM Parameter Store)
aws ssm put-parameter --name "/app/prod/DATABASE_URL" --value "..." --type SecureString

# Cloudflare Workers
wrangler secret put DATABASE_URL

Database: us-east-1
Serverless functions: us-east-1 (same region as DB)
Edge functions: All regions (for middleware, auth checks)
CDN: Global (for static assets and cached API responses)

// app/api/export/route.ts
import { db } from "@/lib/db";
import { requireAuth } from "@/lib/auth-guard";

export async function GET(request: Request) {
  const session = await requireAuth();
  const url = new URL(request.url);
  const format = url.searchParams.get("format") ?? "json";

  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      const batchSize = 100;
      let cursor: string | undefined;

      // Stream header
      if (format === "csv") {
        controller.enqueue(encoder.encode("id,title,status,created_at\n"));
      } else {
        controller.enqueue(encoder.encode('{"data":[\n'));
      }

      let isFirst = true;

      while (true) {
        const posts = await db.post.findMany({
          where: { authorId: session.user.id },
          orderBy: { createdAt: "desc" },
          take: batchSize,
          ...(cursor && { cursor: { id: cursor }, skip: 1 }),
          select: { id: true, title: true, status: true, createdAt: true },
        });

        if (posts.length === 0) break;

        for (const post of posts) {
          if (format === "csv") {
            controller.enqueue(
              encoder.encode(`${post.id},"${post.title}",${post.status},${post.createdAt.toISOString()}\n`)
            );
          } else {
            const prefix = isFirst ? "" : ",\n";
            controller.enqueue(encoder.encode(prefix + JSON.stringify(post)));
            isFirst = false;
          }
        }

        cursor = posts[posts.length - 1].id;
        if (posts.length < batchSize) break;
      }

      // Stream footer
      if (format !== "csv") {
        controller.enqueue(encoder.encode("\n]}"));
      }

      controller.close();
    },
  });

  return new Response(stream, {
    headers: {
      "Content-Type": format === "csv" ? "text/csv" : "application/json",
      "Content-Disposition": `attachment; filename="posts-export.${format}"`,
      "Transfer-Encoding": "chunked",
    },
  });
}

export const maxDuration = 60; // Allow up to 60s for large exports

// src/worker.ts
interface Env {
  DB: D1Database;
  CACHE: KVNamespace;
  ASSETS: R2Bucket;
  API_KEY: string;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    // CORS headers
    const corsHeaders = {
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type, Authorization",
    };

    if (request.method === "OPTIONS") {
      return new Response(null, { headers: corsHeaders });
    }

    try {
      // GET /api/posts — cached list
      if (url.pathname === "/api/posts" && request.method === "GET") {
        // Check KV cache
        const cached = await env.CACHE.get("posts:list", "json");
        if (cached) {
          return Response.json({ data: cached, cached: true }, { headers: corsHeaders });
        }

        // Query D1
        const { results } = await env.DB.prepare(
          "SELECT id, title, status, created_at FROM posts WHERE status = ? ORDER BY created_at DESC LIMIT 50"
        ).bind("published").all();

        // Cache for 5 minutes
        await env.CACHE.put("posts:list", JSON.stringify(results), { expirationTtl: 300 });

        return Response.json({ data: results, cached: false }, { headers: corsHeaders });
      }

      // POST /api/posts — create
      if (url.pathname === "/api/posts" && request.method === "POST") {
        const auth = request.headers.get("Authorization");
        if (auth !== `Bearer ${env.API_KEY}`) {
          return Response.json({ error: "Unauthorized" }, { status: 401, headers: corsHeaders });
        }

        const body = await request.json() as { title: string; content: string };
        const id = crypto.randomUUID();

        await env.DB.prepare(
          "INSERT INTO posts (id, title, content, status, created_at) VALUES (?, ?, ?, ?, datetime('now'))"
        ).bind(id, body.title, body.content, "published").run();

        // Invalidate cache
        await env.CACHE.delete("posts:list");

        return Response.json({ data: { id } }, { status: 201, headers: corsHeaders });
      }

      // GET /files/:key — serve from R2
      if (url.pathname.startsWith("/files/")) {
        const key = url.pathname.replace("/files/", "");
        const object = await env.ASSETS.get(key);

        if (!object) {
          return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
        }

        return new Response(object.body, {
          headers: {
            "Content-Type": object.httpMetadata?.contentType ?? "application/octet-stream",
            "Cache-Control": "public, max-age=31536000, immutable",
            ...corsHeaders,
          },
        });
      }

      return Response.json({ error: "Not found" }, { status: 404, headers: corsHeaders });
    } catch (error) {
      console.error("Worker error:", error);
      return Response.json(
        { error: "Internal server error" },
        { status: 500, headers: corsHeaders }
      );
    }
  },
};

// handler.ts
import type { SQSHandler, SQSRecord } from "aws-lambda";
import { db } from "./lib/db";
import { sendEmail } from "./lib/email";

interface EmailJob {
  to: string;
  subject: string;
  template: string;
  data: Record<string, unknown>;
}

export const handler: SQSHandler = async (event) => {
  const results = await Promise.allSettled(
    event.Records.map((record) => processRecord(record))
  );

  // Report failures for SQS to retry
  const failures = results
    .map((result, index) => ({
      result,
      record: event.Records[index],
    }))
    .filter(({ result }) => result.status === "rejected");

  if (failures.length > 0) {
    // Return failed message IDs for SQS partial batch failure
    return {
      batchItemFailures: failures.map(({ record }) => ({
        itemIdentifier: record.messageId,
      })),
    };
  }
};

async function processRecord(record: SQSRecord) {
  const job: EmailJob = JSON.parse(record.body);

  console.log(JSON.stringify({
    level: "info",
    messageId: record.messageId,
    to: job.to,
    template: job.template,
    msg: "Processing email job",
  }));

  await sendEmail(job);

  // Record delivery
  await db.emailLog.create({
    data: {
      to: job.to,
      subject: job.subject,
      template: job.template,
      sentAt: new Date(),
      messageId: record.messageId,
    },
  });
}

// lib/db.ts (Neon serverless driver + Drizzle)
import { neon } from "@neondatabase/serverless";
import { drizzle } from "drizzle-orm/neon-http";
import * as schema from "@/db/schema";

// HTTP-based connection — no persistent TCP connection
const sql = neon(process.env.DATABASE_URL!);
export const db = drizzle(sql, { schema });

// Usage in API route
// app/api/posts/route.ts
import { db } from "@/lib/db";
import { posts } from "@/db/schema";
import { desc, eq } from "drizzle-orm";

export async function GET() {
  const results = await db
    .select({
      id: posts.id,
      title: posts.title,
      createdAt: posts.createdAt,
    })
    .from(posts)
    .where(eq(posts.status, "published"))
    .orderBy(desc(posts.createdAt))
    .limit(20);

  return Response.json({ data: results });
}

// For connection pooling with WebSockets (more performant for high-throughput)
import { Pool } from "@neondatabase/serverless";
import { drizzle } from "drizzle-orm/neon-serverless";

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
export const dbPooled = drizzle(pool, { schema });

// app/api/uploads/presign/route.ts
import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
import { randomUUID } from "crypto";
import { z } from "zod";
import { requireAuth } from "@/lib/auth-guard";

const s3 = new S3Client({
  region: process.env.AWS_REGION!,
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
  },
});

const PresignSchema = z.object({
  filename: z.string().min(1).max(255),
  contentType: z.enum([
    "image/jpeg", "image/png", "image/webp", "image/gif",
    "application/pdf",
    "text/csv",
  ]),
  size: z.number().max(10 * 1024 * 1024), // 10MB max
});

export async function POST(request: Request) {
  const session = await requireAuth();
  const body = PresignSchema.parse(await request.json());

  const extension = body.filename.split(".").pop() ?? "bin";
  const key = `uploads/${session.user.organizationId}/${randomUUID()}.${extension}`;

  const command = new PutObjectCommand({
    Bucket: process.env.S3_BUCKET!,
    Key: key,
    ContentType: body.contentType,
    ContentLength: body.size,
    Metadata: {
      userId: session.user.id,
      originalFilename: body.filename,
    },
  });

  const uploadUrl = await getSignedUrl(s3, command, { expiresIn: 600 });

  return Response.json({
    uploadUrl,
    fileUrl: `${process.env.CDN_URL}/${key}`,
    key,
  });
}

// app/api/uploads/confirm/route.ts
// Called after client uploads to confirm and create DB record
import { db } from "@/lib/db";
import { requireAuth } from "@/lib/auth-guard";

export async function POST(request: Request) {
  const session = await requireAuth();
  const { key, filename, contentType, size } = await request.json();

  const upload = await db.upload.create({
    data: {
      key,
      filename,
      contentType,
      size,
      userId: session.user.id,
      organizationId: session.user.organizationId!,
      url: `${process.env.CDN_URL}/${key}`,
    },
  });

  return Response.json({ data: upload }, { status: 201 });
}

const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 5000);

try {
  const response = await fetch(url, { signal: controller.signal });
} finally {
  clearTimeout(timeout);
}