// Edge-native request handling
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const cache = caches.default;
    const cacheKey = new Request(request.url, request);
 
    // L1: Edge cache (fastest, <1ms)
    let response = await cache.match(cacheKey);
    if (response) {
      response.headers.set('X-Cache', 'HIT');
      return response;
    }
 
    // L2: Edge KV (fast, <5ms)
    const kvKey = new URL(request.url).pathname;
    const kvData = await env.KV.get(kvKey, 'json');
    if (kvData) {
      response = Response.json(kvData);
      response.headers.set('X-Cache', 'KV-HIT');
      await cache.put(cacheKey, response.clone());
      return response;
    }
 
    // L3: Edge database (moderate, <20ms)
    const dbResult = await env.DB.prepare(
      'SELECT * FROM pages WHERE path = ?'
    ).bind(kvKey).first();
 
    if (dbResult) {
      response = Response.json(dbResult);
      response.headers.set('X-Cache', 'DB-HIT');
      // Populate KV for next request
      await env.KV.put(kvKey, JSON.stringify(dbResult), { expirationTtl: 300 });
      await cache.put(cacheKey, response.clone());
      return response;
    }
 
    // L4: Origin (slowest, 50-200ms)
    response = await fetch(request);
    response.headers.set('X-Cache', 'MISS');
    return response;
  },
};

// Turso: Database replicated to edge locations
import { createClient } from '@libsql/client';
 
// Client automatically routes to nearest replica
const db = createClient({
  url: 'libsql://your-db.turso.io',
  authToken: env.TURSO_AUTH_TOKEN,
});
 
export default {
  async fetch(request: Request): Promise<Response> {
    // This query runs against the nearest edge replica
    // Latency: <5ms regardless of user location
    const result = await db.execute(
      'SELECT * FROM products WHERE category = ?',
      ['electronics']
    );
 
    return Response.json(result.rows);
  },
};

// Geo-based routing at the edge
export default {
  async fetch(request: Request): Promise<Response> {
    const country = request.cf?.country || 'US';
    const continent = request.cf?.continent || 'NA';
 
    // Map regions to origin servers
    const origins: Record<string, string> = {
      AS: 'https://api-as.example.com',
      EU: 'https://api-eu.example.com',
      NA: 'https://api-na.example.com',
      SA: 'https://api-na.example.com', // Fall back to NA
      AF: 'https://api-eu.example.com', // Fall back to EU
      OC: 'https://api-as.example.com', // Fall back to AS
    };
 
    const origin = origins[continent] || origins.NA;
 
    // Forward to nearest origin
    const url = new URL(request.url);
    const response = await fetch(`${origin}${url.pathname}`, {
      method: request.method,
      headers: request.headers,
    });
 
    // Add routing headers for debugging
    const newResponse = new Response(response.body, response);
    newResponse.headers.set('X-Routed-To', origin);
    newResponse.headers.set('X-User-Country', country);
 
    return newResponse;
  },
};

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const cache = caches.default;
    const cacheKey = new Request(request.url, request);
    const cached = await cache.match(cacheKey);
 
    if (cached) {
      const age = parseInt(cached.headers.get('Age') || '0');
      const maxAge = parseInt(
        cached.headers.get('Cache-Control')?.match(/max-age=(\d+)/)?.[1] || '60'
      );
 
      if (age < maxAge) {
        // Fresh — serve immediately
        return cached;
      }
 
      // Stale — serve immediately but revalidate in background
      const responsePromise = fetchFromOrigin(request);
      c.waitUntil(
        responsePromise.then(async (fresh) => {
          fresh.headers.set('Cache-Control', `max-age=${maxAge}`);
          await cache.put(cacheKey, fresh);
        })
      );
 
      return cached; // Serve stale content
    }
 
    // No cache — fetch from origin
    const response = await fetchFromOrigin(request);
    response.headers.set('Cache-Control', 'max-age=60');
    await cache.put(cacheKey, response.clone());
    return response;
  },
};

# Create Cloudflare Workers project
npm create cloudflare@latest edge-blog -- --type=hello-world
cd edge-blog
 
# Install dependencies
npm install hono @libsql/client

-- Turso/LibSQL schema
CREATE TABLE posts (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  slug TEXT UNIQUE NOT NULL,
  title TEXT NOT NULL,
  content TEXT NOT NULL,
  author TEXT NOT NULL,
  published_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  views INTEGER DEFAULT 0
);
 
CREATE INDEX idx_posts_slug ON posts(slug);
CREATE INDEX idx_posts_published ON posts(published_at DESC);

import { Hono } from 'hono';
import { createClient } from '@libsql/client';
 
type Bindings = {
  TURSO_URL: string;
  TURSO_AUTH_TOKEN: string;
  KV: KVNamespace;
};
 
const app = new Hono<{ Bindings: Bindings }>();
 
// Middleware: Edge timing
app.use('*', async (c, next) => {
  const start = Date.now();
  await next();
  c.header('X-Edge-Time', `${Date.now() - start}ms`);
  c.header('X-Edge-Region', c.req.header('cf-colo') || 'unknown');
});
 
// Homepage: Latest posts from edge database
app.get('/', async (c) => {
  const db = createClient({
    url: c.env.TURSO_URL,
    authToken: c.env.TURSO_AUTH_TOKEN,
  });
 
  const posts = await db.execute(
    'SELECT id, slug, title, author, published_at FROM posts ORDER BY published_at DESC LIMIT 20'
  );
 
  return c.html(`
    <!DOCTYPE html>
    <html>
      <head><title>Edge Blog</title></head>
      <body>
        <h1>Latest Posts</h1>
        ${posts.rows
          .map(
            (p) => `
          <article>
            <h2><a href="/posts/${p.slug}">${p.title}</a></h2>
            <span>By ${p.author} on ${p.published_at}</span>
          </article>
        `
          )
          .join('')}
      </body>
    </html>
  `);
});
 
// Post page: Single post with view counter
app.get('/posts/:slug', async (c) => {
  const slug = c.req.param('slug');
  const db = createClient({
    url: c.env.TURSO_URL,
    authToken: c.env.TURSO_AUTH_TOKEN,
  });
 
  // Increment view count (write to edge DB)
  await db.execute('UPDATE posts SET views = views + 1 WHERE slug = ?', [slug]);
 
  // Read post (from nearest edge replica)
  const post = await db.execute('SELECT * FROM posts WHERE slug = ?', [slug]);
 
  if (post.rows.length === 0) {
    return c.html('<h1>Post not found</h1>', 404);
  }
 
  const p = post.rows[0];
  return c.html(`
    <!DOCTYPE html>
    <html>
      <head><title>${p.title}</title></head>
      <body>
        <h1>${p.title}</h1>
        <p>By ${p.author} · ${p.views} views</p>
        <div>${p.content}</div>
      </body>
    </html>
  `);
});
 
export default app;

// Edge performance monitoring middleware
export function edgeMetrics() {
  return async (c: Context, next: () => Promise<void>) => {
    const start = performance.now();
    const startCPU = Date.now();
 
    await next();
 
    const duration = performance.now() - start;
 
    // Log metrics for analysis
    const metrics = {
      path: c.req.path,
      method: c.req.method,
      status: c.res.status,
      duration: Math.round(duration * 100) / 100,
      edgeLocation: c.req.header('cf-colo'),
      country: c.req.header('cf-ipcountry'),
      cacheStatus: c.res.headers.get('X-Cache'),
      timestamp: new Date().toISOString(),
    };
 
    // Send to analytics (non-blocking)
    c.executionCtx.waitUntil(
      fetch('https://analytics.example.com/edge-metrics', {
        method: 'POST',
        body: JSON.stringify(metrics),
      })
    );
  };
}

// Stream data from edge to client
export default {
  async fetch(request: Request): Promise<Response> {
    const { readable, writable } = new TransformStream();
    const writer = writable.getWriter();
 
    // Stream data in chunks from edge
    (async () => {
      const encoder = new TextEncoder();
 
      for (let i = 0; i < 100; i++) {
        await writer.write(
          encoder.encode(`data: ${JSON.stringify({ count: i })}\n\n`)
        );
        await new Promise((r) => setTimeout(r, 100));
      }
 
      await writer.close();
    })();
 
    return new Response(readable, {
      headers: {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
      },
    });
  },
};

// Multi-layer caching: browser → edge cache → edge KV → origin
async function multiLayerFetch(
  request: Request,
  env: Env
): Promise<Response> {
  const url = new URL(request.url);
  const key = url.pathname;
 
  // L1: Browser cache (checked by client, controlled via headers)
  // L2: Edge cache (CDN layer)
  const cache = caches.default;
  const cached = await cache.match(request);
  if (cached) return cached;
 
  // L3: Edge KV (persistent key-value store)
  const kvData = await env.KV.get(key, { type: 'json' });
  if (kvData) {
    const response = Response.json(kvData);
    await cache.put(request, response.clone());
    return response;
  }
 
  // L4: Origin server
  const response = await fetch(request);
  const data = await response.json();
 
  // Populate all layers
  await env.KV.put(key, JSON.stringify(data), { expirationTtl: 300 });
  const cacheableResponse = Response.json(data, {
    headers: { 'Cache-Control': 's-maxage=60' },
  });
  await cache.put(request, cacheableResponse.clone());
 
  return cacheableResponse;
}

import { unstable_dev } from 'wrangler';
 
describe('Edge Blog Application', () => {
  let worker: any;
 
  beforeAll(async () => {
    worker = await unstable_dev('src/index.ts', {
      experimental: { disableExperimentalWarning: true },
    });
  });
 
  afterAll(async () => {
    await worker.stop();
  });
 
  test('homepage renders within 50ms', async () => {
    const start = performance.now();
    const resp = await worker.fetch('/');
    const duration = performance.now() - start;
 
    expect(resp.status).toBe(200);
    expect(duration).toBeLessThan(50);
  });
 
  test('includes edge timing headers', async () => {
    const resp = await worker.fetch('/');
    expect(resp.headers.get('X-Edge-Time')).toBeDefined();
    expect(resp.headers.get('X-Edge-Region')).toBeDefined();
  });
 
  test('blog post returns correct content', async () => {
    const resp = await worker.fetch('/posts/test-post');
    const html = await resp.text();
    expect(html).toContain('test-post');
  });
});