Build & Deploy Fullstack Edge API with Wrangler, D1, and KV

export interface Env {
  DB: D1Database;
  CACHE_KV: KVNamespace;
}

interface Product {
  id: string;
  name: string;
  price: number;
  created_at?: string;
}

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

    // Route: GET /api/products/:id
    if (method === 'GET' && path.startsWith('/api/products/')) {
      const id = path.replace('/api/products/', '');
      const cacheKey = `product:${id}`;

      // 1. Try reading from KV Cache
      const cached = await env.CACHE_KV.get(cacheKey, 'json');
      if (cached) {
        return Response.json(
          { source: 'kv-cache', data: cached },
          { headers: { 'X-Cache-Status': 'HIT', 'Content-Type': 'application/json' } }
        );
      }

      // 2. Cache Miss: Query D1 Database
      const product = await env.DB.prepare('SELECT * FROM products WHERE id = ?')
        .bind(id)
        .first<Product>();

      if (!product) {
        return Response.json({ error: 'Product not found' }, { status: 404 });
      }

      // 3. Store in KV with a 60-second expiration TTL
      ctx.waitUntil(
        env.CACHE_KV.put(cacheKey, JSON.stringify(product), {
          expirationTtl: 60,
        })
      );

      return Response.json(
        { source: 'd1-database', data: product },
        { headers: { 'X-Cache-Status': 'MISS', 'Content-Type': 'application/json' } }
      );
    }

    // Route: POST /api/products
    if (method === 'POST' && path === '/api/products') {
      const body = (await request.json()) as Partial<Product>;
      if (!body.name || !body.price) {
        return Response.json({ error: 'Missing name or price' }, { status: 400 });
      }

      const id = `prod_${Date.now()}`;
      await env.DB.prepare('INSERT INTO products (id, name, price) VALUES (?, ?, ?)')
        .bind(id, body.name, body.price)
        .run();

      const newProduct: Product = { id, name: body.name, price: body.price };

      // Invalidate or pre-populate cache
      await env.CACHE_KV.put(`product:${id}`, JSON.stringify(newProduct), {
        expirationTtl: 300,
      });

      return Response.json({ success: true, product: newProduct }, { status: 201 });
    }

    return new Response('Edge API is up and running!', { status: 200 });
  },
};

use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tower_service::Service;
use worker::*;

#[derive(Clone)]
struct AppState {
    env: Arc<worker::Env>,
}

#[derive(Serialize, Deserialize)]
struct Product {
    id: String,
    name: String,
    price: f64,
}

// GET /api/products/:id with KV Cache-Aside & D1 fallback
async fn get_product(
    Path(id): Path<String>,
    State(state): State<AppState>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
    let kv = state.env.kv("CACHE_KV").map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    let cache_key = format!("product:{}", id);

    // 1. Check KV Cache
    if let Ok(Some(cached_json)) = kv.get(&cache_key).text().await {
        return Ok((
            StatusCode::OK,
            [("X-Cache-Status", "HIT"), ("Content-Type", "application/json")],
            cached_json,
        ));
    }

    // 2. Cache Miss: Query D1 Database
    let d1 = state.env.d1("DB").map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
    let statement = d1.prepare("SELECT id, name, price FROM products WHERE id = ?1").bind(&[&id.into()])
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let product = statement.first::<Product>(None).await
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
        .ok_or_else(|| (StatusCode::NOT_FOUND, "Product not found".to_string()))?;

    let json_str = serde_json::to_string(&product)
        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    // 3. Populate KV Cache with 60s TTL
    let _ = kv.put(&cache_key, &json_str).unwrap().expiration_ttl(60).execute().await;

    Ok((
        StatusCode::OK,
        [("X-Cache-Status", "MISS"), ("Content-Type", "application/json")],
        json_str,
    ))
}

#[event(fetch)]
async fn fetch(req: HttpRequest, env: Env, _ctx: Context) -> Result<axum::http::Response<axum::body::Body>> {
    let state = AppState { env: Arc::new(env) };
    let mut router = Router::new()
        .route("/api/products/:id", get(get_product))
        .with_state(state);

    let response = router.call(req).await.unwrap();
    Ok(response)
}