mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
Every page now loads /webmcp.js, scripts/webmcp.ts with its types stripped (npm run webmcp). Where the browser has document.modelContext it registers two read-only tools: search_skills over the published skills index, and get_skill, which returns a skill's markdown checked against the index digest. The markdown alternate link moves from build.py to site.py, so CI holds every page to it. The API catalog gains the site itself (llms.txt and the skills index) and hanzo.ai/agents; the live discovery check now fetches every catalog link. tests/site.mjs drives the tools through a recording modelContext, and checks a browser without one loads clean.
809 lines
31 KiB
HTML
809 lines
31 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>infrastructure-cloudflare-workers</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/infrastructure-cloudflare-workers">
|
|
<link rel="alternate" type="text/markdown" href="/infrastructure-cloudflare-workers.md">
|
|
<script type="module" src="/webmcp.js"></script>
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/infrastructure-cloudflare-workers.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>infrastructure-cloudflare-workers</h1><p class="lede">Building serverless APIs at the edge (low latency globally)</p><h1>Cloudflare Workers</h1>
|
|
<p><strong>Scope</strong>: Edge computing with Cloudflare Workers - Edge functions, KV storage, Durable Objects, R2 <strong>Lines</strong>: 365 <strong>Last Updated</strong>: 2025-10-18 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<hr>
|
|
<h2>When to Use This Skill</h2>
|
|
<p><strong>Activate when</strong>:</p>
|
|
<ul><li>Building serverless APIs at the edge (low latency globally)</li><li>Implementing CDN logic and custom routing</li><li>A/B testing and feature flags</li><li>Authentication and authorization at the edge</li><li>API proxying and transformation</li><li>Static site generation with dynamic elements</li></ul>
|
|
<p><strong>Prerequisites</strong>:</p>
|
|
<ul><li>Cloudflare account (free tier available)</li><li>Node.js installed for Wrangler CLI</li><li>Wrangler CLI installed (<code>npm install -g wrangler</code>)</li><li>Basic JavaScript/TypeScript knowledge</li><li>Cloudflare domain (for production deployment)</li></ul>
|
|
<p><strong>Common scenarios</strong>:</p>
|
|
<ul><li>API endpoints with global low latency</li><li>Image resizing and optimization</li><li>Request/response manipulation</li><li>Rate limiting and bot protection</li><li>Geo-routing and localization</li><li>Edge-side rendering (ESR)</li></ul>
|
|
<hr>
|
|
<h2>Core Concepts</h2>
|
|
<h3>1. Basic Worker</h3>
|
|
<pre><code class="lang-javascript">// src/index.js - Simple worker
|
|
export default {
|
|
async fetch(request, env, ctx) {
|
|
const url = new URL(request.url);
|
|
|
|
// Simple routing
|
|
if (url.pathname === '/api/hello') {
|
|
return new Response(JSON.stringify({
|
|
message: 'Hello from the edge!',
|
|
location: request.cf.city,
|
|
country: request.cf.country
|
|
}), {
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'Access-Control-Allow-Origin': '*'
|
|
}
|
|
});
|
|
}
|
|
|
|
// 404 response
|
|
return new Response('Not Found', { status: 404 });
|
|
}
|
|
};</code></pre>
|
|
<h3>2. Wrangler Configuration</h3>
|
|
<pre><code class="lang-toml"># wrangler.toml
|
|
name = "my-worker"
|
|
main = "src/index.js"
|
|
compatibility_date = "2024-01-01"
|
|
|
|
# Environment variables
|
|
[vars]
|
|
ENVIRONMENT = "production"
|
|
API_VERSION = "v1"
|
|
|
|
# KV Namespace bindings
|
|
[[kv_namespaces]]
|
|
binding = "CACHE"
|
|
id = "abcdef1234567890abcdef1234567890"
|
|
|
|
# Durable Object bindings
|
|
[[durable_objects.bindings]]
|
|
name = "COUNTER"
|
|
class_name = "Counter"
|
|
|
|
# R2 bucket bindings
|
|
[[r2_buckets]]
|
|
binding = "ASSETS"
|
|
bucket_name = "my-assets"
|
|
|
|
# Secrets (set with: wrangler secret put SECRET_NAME)
|
|
# Access via env.SECRET_NAME
|
|
|
|
# Routes (custom domain)
|
|
[[routes]]
|
|
pattern = "api.example.com/*"
|
|
zone_name = "example.com"
|
|
|
|
# Workers for Platforms (optional)
|
|
[dispatch_namespaces]
|
|
binding = "DISPATCHER"
|
|
namespace = "my-namespace"</code></pre>
|
|
<h3>3. Request/Response Handling</h3>
|
|
<pre><code class="lang-typescript">// src/index.ts - TypeScript worker
|
|
interface Env {
|
|
CACHE: KVNamespace;
|
|
API_KEY: string;
|
|
ENVIRONMENT: string;
|
|
}
|
|
|
|
export default {
|
|
async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
|
|
// CORS handling
|
|
if (request.method === 'OPTIONS') {
|
|
return handleCORS();
|
|
}
|
|
|
|
// Authentication
|
|
const apiKey = request.headers.get('X-API-Key');
|
|
if (apiKey !== env.API_KEY) {
|
|
return new Response('Unauthorized', { status: 401 });
|
|
}
|
|
|
|
// Route handling
|
|
switch (url.pathname) {
|
|
case '/api/data':
|
|
return handleData(request, env, ctx);
|
|
case '/api/upload':
|
|
return handleUpload(request, env);
|
|
default:
|
|
return new Response('Not Found', { status: 404 });
|
|
}
|
|
}
|
|
};
|
|
|
|
function handleCORS(): Response {
|
|
return new Response(null, {
|
|
headers: {
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
|
|
'Access-Control-Allow-Headers': 'Content-Type, X-API-Key',
|
|
'Access-Control-Max-Age': '86400',
|
|
}
|
|
});
|
|
}
|
|
|
|
async function handleData(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
|
|
const cacheKey = new URL(request.url).pathname;
|
|
|
|
// Check cache first
|
|
const cached = await env.CACHE.get(cacheKey, 'json');
|
|
if (cached) {
|
|
return Response.json(cached, {
|
|
headers: { 'X-Cache': 'HIT' }
|
|
});
|
|
}
|
|
|
|
// Fetch data
|
|
const data = await fetchData();
|
|
|
|
// Cache in background
|
|
ctx.waitUntil(
|
|
env.CACHE.put(cacheKey, JSON.stringify(data), {
|
|
expirationTtl: 3600 // 1 hour
|
|
})
|
|
);
|
|
|
|
return Response.json(data, {
|
|
headers: { 'X-Cache': 'MISS' }
|
|
});
|
|
}
|
|
|
|
async function fetchData() {
|
|
// Fetch from origin API
|
|
const response = await fetch('https://api.example.com/data');
|
|
return response.json();
|
|
}</code></pre>
|
|
<h3>4. KV Storage</h3>
|
|
<pre><code class="lang-typescript">// KV operations
|
|
interface Env {
|
|
CACHE: KVNamespace;
|
|
}
|
|
|
|
export default {
|
|
async fetch(request: Request, env: Env): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
const key = url.searchParams.get('key');
|
|
|
|
if (request.method === 'GET') {
|
|
// Get value
|
|
const value = await env.CACHE.get(key);
|
|
if (!value) {
|
|
return new Response('Not Found', { status: 404 });
|
|
}
|
|
return new Response(value);
|
|
}
|
|
|
|
if (request.method === 'POST') {
|
|
// Put value with expiration
|
|
const value = await request.text();
|
|
await env.CACHE.put(key, value, {
|
|
expirationTtl: 3600, // Seconds
|
|
metadata: { timestamp: Date.now() }
|
|
});
|
|
return new Response('Stored', { status: 201 });
|
|
}
|
|
|
|
if (request.method === 'DELETE') {
|
|
// Delete value
|
|
await env.CACHE.delete(key);
|
|
return new Response('Deleted', { status: 204 });
|
|
}
|
|
|
|
// List keys with prefix
|
|
if (url.pathname === '/list') {
|
|
const prefix = url.searchParams.get('prefix') || '';
|
|
const list = await env.CACHE.list({ prefix, limit: 100 });
|
|
return Response.json(list.keys);
|
|
}
|
|
|
|
return new Response('Method Not Allowed', { status: 405 });
|
|
}
|
|
};</code></pre>
|
|
<h3>5. Durable Objects</h3>
|
|
<pre><code class="lang-typescript">// src/counter.ts - Durable Object
|
|
export class Counter {
|
|
state: DurableObjectState;
|
|
value: number;
|
|
|
|
constructor(state: DurableObjectState, env: Env) {
|
|
this.state = state;
|
|
this.value = 0;
|
|
}
|
|
|
|
async initialize() {
|
|
// Load state from storage
|
|
const stored = await this.state.storage.get('value');
|
|
this.value = stored || 0;
|
|
}
|
|
|
|
async fetch(request: Request): Promise<Response> {
|
|
await this.initialize();
|
|
|
|
const url = new URL(request.url);
|
|
|
|
if (url.pathname === '/increment') {
|
|
this.value++;
|
|
await this.state.storage.put('value', this.value);
|
|
return Response.json({ value: this.value });
|
|
}
|
|
|
|
if (url.pathname === '/decrement') {
|
|
this.value--;
|
|
await this.state.storage.put('value', this.value);
|
|
return Response.json({ value: this.value });
|
|
}
|
|
|
|
if (url.pathname === '/get') {
|
|
return Response.json({ value: this.value });
|
|
}
|
|
|
|
return new Response('Not Found', { status: 404 });
|
|
}
|
|
}
|
|
|
|
// src/index.ts - Use Durable Object
|
|
export { Counter } from './counter';
|
|
|
|
interface Env {
|
|
COUNTER: DurableObjectNamespace;
|
|
}
|
|
|
|
export default {
|
|
async fetch(request: Request, env: Env): Promise<Response> {
|
|
// Get Durable Object instance by ID
|
|
const id = env.COUNTER.idFromName('global-counter');
|
|
const stub = env.COUNTER.get(id);
|
|
|
|
// Forward request to Durable Object
|
|
return stub.fetch(request);
|
|
}
|
|
};</code></pre>
|
|
<h3>6. R2 Storage</h3>
|
|
<pre><code class="lang-typescript">// R2 bucket operations
|
|
interface Env {
|
|
ASSETS: R2Bucket;
|
|
}
|
|
|
|
export default {
|
|
async fetch(request: Request, env: Env): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
const key = url.pathname.slice(1); // Remove leading /
|
|
|
|
if (request.method === 'GET') {
|
|
// Get object
|
|
const object = await env.ASSETS.get(key);
|
|
|
|
if (!object) {
|
|
return new Response('Not Found', { status: 404 });
|
|
}
|
|
|
|
const headers = new Headers();
|
|
object.writeHttpMetadata(headers);
|
|
headers.set('etag', object.httpEtag);
|
|
|
|
return new Response(object.body, { headers });
|
|
}
|
|
|
|
if (request.method === 'PUT') {
|
|
// Upload object
|
|
await env.ASSETS.put(key, request.body, {
|
|
httpMetadata: {
|
|
contentType: request.headers.get('content-type') || 'application/octet-stream',
|
|
},
|
|
customMetadata: {
|
|
uploadedBy: 'worker',
|
|
timestamp: new Date().toISOString(),
|
|
}
|
|
});
|
|
|
|
return new Response('Uploaded', { status: 201 });
|
|
}
|
|
|
|
if (request.method === 'DELETE') {
|
|
// Delete object
|
|
await env.ASSETS.delete(key);
|
|
return new Response('Deleted', { status: 204 });
|
|
}
|
|
|
|
return new Response('Method Not Allowed', { status: 405 });
|
|
}
|
|
};</code></pre>
|
|
<hr>
|
|
<h2>Patterns</h2>
|
|
<h3>Edge Caching</h3>
|
|
<pre><code class="lang-typescript">// Cache API with edge caching
|
|
export default {
|
|
async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
|
|
const cache = caches.default;
|
|
|
|
// Try to get from cache
|
|
let response = await cache.match(request);
|
|
if (response) {
|
|
return response;
|
|
}
|
|
|
|
// Fetch from origin
|
|
response = await fetch(request);
|
|
|
|
// Cache successful responses
|
|
if (response.ok) {
|
|
const responseToCache = response.clone();
|
|
ctx.waitUntil(cache.put(request, responseToCache));
|
|
}
|
|
|
|
return response;
|
|
}
|
|
};</code></pre>
|
|
<h3>Request Rewriting</h3>
|
|
<pre><code class="lang-typescript">// Rewrite requests to different origins
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
|
|
// API proxy
|
|
if (url.pathname.startsWith('/api/')) {
|
|
url.hostname = 'api.backend.com';
|
|
url.pathname = url.pathname.replace('/api/', '/v1/');
|
|
|
|
const modifiedRequest = new Request(url.toString(), {
|
|
method: request.method,
|
|
headers: request.headers,
|
|
body: request.body,
|
|
});
|
|
|
|
return fetch(modifiedRequest);
|
|
}
|
|
|
|
// Default to static assets
|
|
url.hostname = 'static.example.com';
|
|
return fetch(url.toString());
|
|
}
|
|
};</code></pre>
|
|
<h3>A/B Testing</h3>
|
|
<pre><code class="lang-typescript">// A/B testing with cookie-based variants
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
|
|
// Check for existing variant cookie
|
|
let variant = getCookie(request, 'ab_variant');
|
|
|
|
if (!variant) {
|
|
// Assign random variant
|
|
variant = Math.random() < 0.5 ? 'A' : 'B';
|
|
}
|
|
|
|
// Fetch variant-specific content
|
|
const response = await fetch(`https://origin.com/${variant}${url.pathname}`);
|
|
|
|
// Set variant cookie
|
|
const newResponse = new Response(response.body, response);
|
|
newResponse.headers.set('Set-Cookie', `ab_variant=${variant}; Path=/; Max-Age=86400`);
|
|
|
|
return newResponse;
|
|
}
|
|
};
|
|
|
|
function getCookie(request: Request, name: string): string | null {
|
|
const cookies = request.headers.get('Cookie');
|
|
if (!cookies) return null;
|
|
|
|
const cookie = cookies.split(';').find(c => c.trim().startsWith(`${name}=`));
|
|
return cookie ? cookie.split('=')[1] : null;
|
|
}</code></pre>
|
|
<h3>Rate Limiting</h3>
|
|
<pre><code class="lang-typescript">// Rate limiting with Durable Objects
|
|
export class RateLimiter {
|
|
state: DurableObjectState;
|
|
requests: Map<string, number[]>;
|
|
|
|
constructor(state: DurableObjectState) {
|
|
this.state = state;
|
|
this.requests = new Map();
|
|
}
|
|
|
|
async fetch(request: Request): Promise<Response> {
|
|
const clientId = request.headers.get('CF-Connecting-IP') || 'unknown';
|
|
const now = Date.now();
|
|
const windowMs = 60000; // 1 minute
|
|
const maxRequests = 100;
|
|
|
|
// Get request timestamps for this client
|
|
let timestamps = this.requests.get(clientId) || [];
|
|
|
|
// Remove old timestamps outside window
|
|
timestamps = timestamps.filter(ts => now - ts < windowMs);
|
|
|
|
// Check if limit exceeded
|
|
if (timestamps.length >= maxRequests) {
|
|
return new Response('Rate limit exceeded', {
|
|
status: 429,
|
|
headers: {
|
|
'Retry-After': '60'
|
|
}
|
|
});
|
|
}
|
|
|
|
// Add current request
|
|
timestamps.push(now);
|
|
this.requests.set(clientId, timestamps);
|
|
|
|
return Response.json({
|
|
allowed: true,
|
|
remaining: maxRequests - timestamps.length
|
|
});
|
|
}
|
|
}</code></pre>
|
|
<h3>Image Resizing</h3>
|
|
<pre><code class="lang-typescript">// Image transformation
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
const url = new URL(request.url);
|
|
|
|
// Parse resize parameters
|
|
const width = parseInt(url.searchParams.get('width') || '800');
|
|
const quality = parseInt(url.searchParams.get('quality') || '85');
|
|
const format = url.searchParams.get('format') || 'auto';
|
|
|
|
// Fetch original image
|
|
const imageUrl = url.searchParams.get('url');
|
|
if (!imageUrl) {
|
|
return new Response('Missing url parameter', { status: 400 });
|
|
}
|
|
|
|
const response = await fetch(imageUrl);
|
|
|
|
// Transform with Cloudflare Image Resizing
|
|
return new Response(response.body, {
|
|
headers: {
|
|
'Content-Type': 'image/jpeg',
|
|
'Cache-Control': 'public, max-age=31536000',
|
|
'CF-Image-Width': width.toString(),
|
|
'CF-Image-Quality': quality.toString(),
|
|
'CF-Image-Format': format,
|
|
}
|
|
});
|
|
}
|
|
};</code></pre>
|
|
<hr>
|
|
<h2>Quick Reference</h2>
|
|
<h3>Wrangler Commands</h3>
|
|
<pre><code class="lang-bash"># Development
|
|
wrangler dev # Local development server
|
|
wrangler dev --remote # Remote development (actual edge)
|
|
|
|
# Deployment
|
|
wrangler deploy # Deploy to production
|
|
wrangler deploy --env staging # Deploy to staging
|
|
|
|
# KV operations
|
|
wrangler kv:namespace create "CACHE"
|
|
wrangler kv:key put --binding=CACHE "key" "value"
|
|
wrangler kv:key get --binding=CACHE "key"
|
|
wrangler kv:key delete --binding=CACHE "key"
|
|
wrangler kv:key list --binding=CACHE
|
|
|
|
# R2 operations
|
|
wrangler r2 bucket create my-bucket
|
|
wrangler r2 object put my-bucket/file.txt --file=./file.txt
|
|
wrangler r2 object get my-bucket/file.txt
|
|
|
|
# Secrets
|
|
wrangler secret put API_KEY
|
|
wrangler secret delete API_KEY
|
|
wrangler secret list
|
|
|
|
# Logs
|
|
wrangler tail # Stream logs
|
|
wrangler tail --format=pretty
|
|
|
|
# Account info
|
|
wrangler whoami
|
|
wrangler deployments list</code></pre>
|
|
<h3>Worker Limits</h3>
|
|
<pre><code>CPU Time: 10ms (free), 30s (paid) per request
|
|
Memory: 128 MB
|
|
Subrequest limit: 50 (free), 1000 (paid)
|
|
Script size: 1 MB (free), 10 MB (paid)
|
|
KV read: 100,000/day (free), unlimited (paid)
|
|
KV write: 1,000/day (free), unlimited (paid)
|
|
Durable Objects: Paid feature only
|
|
R2 storage: 10 GB (free), unlimited (paid)</code></pre>
|
|
<hr>
|
|
<h2>Anti-Patterns</h2>
|
|
<h3>Critical Violations</h3>
|
|
<pre><code class="lang-typescript">// ❌ NEVER: Store secrets in code
|
|
const API_KEY = "sk-1234567890abcdef"; // NEVER
|
|
|
|
// ✅ CORRECT: Use environment bindings
|
|
interface Env {
|
|
API_KEY: string; // Set with: wrangler secret put API_KEY
|
|
}
|
|
|
|
export default {
|
|
async fetch(request: Request, env: Env): Promise<Response> {
|
|
if (request.headers.get('X-API-Key') !== env.API_KEY) {
|
|
return new Response('Unauthorized', { status: 401 });
|
|
}
|
|
// ...
|
|
}
|
|
};</code></pre>
|
|
<pre><code class="lang-typescript">// ❌ NEVER: Perform blocking operations
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
// CPU-intensive synchronous work
|
|
let result = 0;
|
|
for (let i = 0; i < 1000000000; i++) { // Will hit CPU limit
|
|
result += i;
|
|
}
|
|
return Response.json({ result });
|
|
}
|
|
};
|
|
|
|
// ✅ CORRECT: Use Durable Objects for stateful work
|
|
// Or offload to origin API for heavy computation</code></pre>
|
|
<pre><code class="lang-typescript">// ❌ NEVER: Use global state
|
|
let counter = 0; // Not shared across requests!
|
|
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
counter++; // Each request gets own isolate
|
|
return Response.json({ counter }); // Always 1
|
|
}
|
|
};
|
|
|
|
// ✅ CORRECT: Use KV or Durable Objects
|
|
interface Env {
|
|
CACHE: KVNamespace;
|
|
}
|
|
|
|
export default {
|
|
async fetch(request: Request, env: Env): Promise<Response> {
|
|
const counter = parseInt(await env.CACHE.get('counter') || '0');
|
|
await env.CACHE.put('counter', (counter + 1).toString());
|
|
return Response.json({ counter: counter + 1 });
|
|
}
|
|
};</code></pre>
|
|
<h3>Common Mistakes</h3>
|
|
<pre><code class="lang-typescript">// ❌ Don't forget CORS headers
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
return Response.json({ data: 'value' });
|
|
// Browser will block cross-origin requests
|
|
}
|
|
};
|
|
|
|
// ✅ CORRECT: Add CORS headers
|
|
export default {
|
|
async fetch(request: Request): Promise<Response> {
|
|
const headers = {
|
|
'Access-Control-Allow-Origin': '*',
|
|
'Content-Type': 'application/json',
|
|
};
|
|
return Response.json({ data: 'value' }, { headers });
|
|
}
|
|
};</code></pre>
|
|
<hr>
|
|
<h2>Related Skills</h2>
|
|
<p><strong>Infrastructure</strong>:</p>
|
|
<ul><li><code>aws-serverless.md</code> - Alternative serverless platform (Lambda, API Gateway)</li><li><code>infrastructure-security.md</code> - Authentication, authorization patterns</li><li><code>cost-optimization.md</code> - Workers pricing, caching strategies</li></ul>
|
|
<p><strong>Development</strong>:</p>
|
|
<ul><li><code>modal-functions-basics.md</code> - Python-focused serverless alternative</li><li><code>terraform-patterns.md</code> - Infrastructure as Code for Cloudflare resources</li></ul>
|
|
<p><strong>Standards from CLAUDE.md</strong>:</p>
|
|
<ul><li>Use wrangler CLI for all operations</li><li>Store secrets with <code>wrangler secret put</code></li><li>TypeScript for type safety</li><li>Always handle CORS for API endpoints</li><li>Use KV for simple key-value, Durable Objects for complex state</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-18 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/infrastructure-cloudflare-workers.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |