// A simple Cloudflare Worker
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);
    
    if (url.pathname === '/api/hello') {
      return new Response(JSON.stringify({
        message: 'Hello from the edge!',
        location: request.cf.city,  // Cloudflare metadata!
        country: request.cf.country,
        colo: request.cf.colo  // Which datacenter served this
      }), {
        headers: { 'Content-Type': 'application/json' }
      });
    }
    
    return new Response('Not Found', { status: 404 });
  }
};

export default {
  async fetch(request, env) {
    const { CACHE } = env;  // KV namespace from wrangler.toml
    
    const key = new URL(request.url).pathname;
    
    // Try cache first
    let cached = await CACHE.get(key);
    if (cached) {
      return new Response(cached, {
        headers: { 'X-Cache': 'HIT' }
      });
    }
    
    // Fetch from origin
    const response = await fetch('https://api.example.com' + key);
    const data = await response.text();
    
    // Cache for 1 hour
    await CACHE.put(key, data, { expirationTtl: 3600 });
    
    return new Response(data, {
      headers: { 'X-Cache': 'MISS' }
    });
  }
};

// durable-object.js - A per-user rate limiter
export class RateLimiter {
  constructor(state, env) {
    this.state = state;
  }

  async fetch(request) {
    const { pathname } = new URL(request.url);
    
    if (pathname === '/check') {
      const now = Date.now();
      const windowStart = now - 60_000; // 1 minute window
      
      // Read current request log
      let requests = await this.state.storage.get('requests') || [];
      
      // Filter to current window
      requests = requests.filter(t => t > windowStart);
      
      if (requests.length >= 100) {
        return Response.json({ allowed: false, remaining: 0 }, { status: 429 });
      }
      
      // Add current request
      requests.push(now);
      await this.state.storage.put('requests', requests);
      
      return Response.json({ allowed: true, remaining: 100 - requests.length });
    }
  }
}

// Main worker using the Durable Object
export default {
  async fetch(request, env) {
    const userId = request.headers.get('X-User-ID');
    
    // Get or create a Durable Object for this user
    const id = env.RATE_LIMITER.idFromName(userId);
    const rateLimiter = env.RATE_LIMITER.get(id);
    
    // Check rate limit (runs on nearest Cloudflare PoP)
    const checkResponse = await rateLimiter.fetch(new Request('/check'));
    const { allowed } = await checkResponse.json();
    
    if (!allowed) {
      return new Response('Too Many Requests', { status: 429 });
    }
    
    return new Response('OK');
  }
};

export default {
  async fetch(request, env) {
    const { prompt } = await request.json();
    
    // Run LLM inference on Cloudflare's GPU network
    const result = await env.AI.run('@cf/meta/llama-3-8b-instruct', {
      messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: prompt }
      ],
      stream: true  // Streaming supported!
    });
    
    return new Response(result, {
      headers: { 'Content-Type': 'text/event-stream' }
    });
  }
};

// wrangler.toml
name = "my-worker"
main = "src/index.ts"
compatibility_date = "2026-01-01"

[env.production]
vars = { ENVIRONMENT = "production" }
kv_namespaces = [
  { binding = "CACHE", id = "abc123" }
]

# Always set retry logic
[triggers]
crons = ["*/5 * * * *"]  # Cron triggers for background tasks

// Cloudflare Workers with OpenTelemetry
import { trace, context, propagation } from '@opentelemetry/api';

export default {
  async fetch(request, env) {
    const tracer = trace.getTracer('my-worker');
    
    return tracer.startActiveSpan('handle-request', async (span) => {
      try {
        span.setAttributes({
          'http.method': request.method,
          'http.url': request.url,
          'cf.country': request.cf.country
        });
        
        const result = await handleRequest(request, env);
        span.setStatus({ code: SpanStatusCode.OK });
        return result;
        
      } catch (error) {
        span.recordException(error);
        span.setStatus({ code: SpanStatusCode.ERROR });
        throw error;
      } finally {
        span.end();
      }
    });
  }
};