Cloudflare Workers Cheat Sheet: Edge Functions, Durable Objects & Storage

// src/index.ts
export interface Env {
  // Bindings are auto-typed here
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    return new Response('Hello from the edge!');
  },
};

npm create hono my-worker -- --template cloudflare-workers

// src/index.ts
import { Hono } from 'hono';
import { cors } from 'hono/cors';

const app = new Hono<{ Bindings: { DB: D1Database } }>();

app.use('*', cors());

app.get('/', (c) => c.text('Hello from Hono on the edge!'));

app.get('/api/users/:id', async (c) => {
  const id = c.req.param('id');
  const user = await c.env.DB
    .prepare('SELECT * FROM users WHERE id = ?')
    .bind(id)
    .first();
  return c.json(user);
});

app.post('/api/users', async (c) => {
  const { name, email } = await c.req.json();
  await c.env.DB
    .prepare('INSERT INTO users (name, email) VALUES (?, ?)')
    .bind(name, email)
    .run();
  return c.json({ success: true });
});

export default {
  fetch: app.fetch,
};

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

# KV Namespace
[[kv_namespaces]]
binding = "CACHE"
id = "abc123def456..."

# R2 Bucket
[[r2_buckets]]
binding = "ASSETS"
bucket_name = "my-assets-bucket"

# D1 Database
[[d1_databases]]
binding = "DB"
database_name = "my-database"
database_id = "789abc..."

# Durable Objects
[[durable_objects.bindings]]
name = "SESSION_STORE"
class_name = "SessionStore"

# Queues
[[queues.producers]]
queue = "email-jobs"

# Hyperdrive
[[hyperdrive.bindings]]
binding = "DB_PROXY"
id = "hyperdrive_connection_id"

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const cache = env.CACHE;

    // Read
    const cached = await cache.get('homepage-html');
    if (cached) {
      return new Response(cached, {
        headers: { 'Content-Type': 'text/html', 'X-Cache': 'HIT' },
      });
    }

    // Write
    const html = await generateHomepage();
    await cache.put('homepage-html', html, { expirationTtl: 3600 });

    return new Response(html, {
      headers: { 'Content-Type': 'text/html', 'X-Cache': 'MISS' },
    });
  },
};

// List keys with prefix
const keys = await cache.list({ prefix: 'user:', limit: 100 });

// Delete
await cache.delete('homepage-html');

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const assets = env.ASSETS;

    if (request.method === 'POST') {
      // Upload
      const formData = await request.formData();
      const file = formData.get('file') as File;
      await assets.put(file.name, file.stream(), {
        httpMetadata: { contentType: file.type },
        customMetadata: { uploadedBy: 'user-123' },
      });
      return c.json({ url: `/files/${file.name}` });
    }

    if (request.method === 'GET') {
      const key = new URL(request.url).pathname.replace('/files/', '');
      const object = await assets.head(key);
      if (!object) return c.json({ error: 'Not found' }, 404);
      const stream = await assets.get(key);
      return new Response(stream?.body, {
        headers: {
          'Content-Type': object.httpMetadata.contentType ?? 'application/octet-stream',
          'Content-Length': object.size.toString(),
        },
      });
    }
  },
};

// Delete
await assets.delete('filename.jpg');

// List
const listed = await assets.list({ prefix: 'uploads/', limit: 50 });
for (const obj of listed.objects) {
  console.log(obj.key, obj.size, obj.uploaded);
}

-- schema.sql
CREATE TABLE IF NOT EXISTS users (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  email TEXT UNIQUE NOT NULL,
  created_at INTEGER DEFAULT (unixepoch())
);

CREATE TABLE IF NOT EXISTS posts (
  id TEXT PRIMARY KEY,
  user_id TEXT NOT NULL,
  title TEXT NOT NULL,
  content TEXT NOT NULL,
  published INTEGER DEFAULT 0,
  FOREIGN KEY (user_id) REFERENCES users(id)
);

CREATE INDEX idx_posts_user ON posts(user_id);
CREATE INDEX idx_posts_published ON posts(published);

# Create and apply schema
wrangler d1 create my-db
wrangler d1 execute my-db --file=schema.sql --remote
wrangler d1 execute my-db --command="SELECT * FROM users" --remote

// Query from a Worker
const stmt = env.DB.prepare('SELECT * FROM posts WHERE published = 1 ORDER BY created_at DESC');
const { results } = await stmt.all();

const user = await env.DB
  .prepare('SELECT * FROM users WHERE id = ?')
  .bind(userId)
  .first();

await env.DB
  .prepare('INSERT INTO posts (id, user_id, title, content) VALUES (?, ?, ?, ?)')
  .bind(crypto.randomUUID(), userId, title, content)
  .run();

// src/durable.ts
export class SessionStore implements DurableObjectNamespace {
  private state: DurableObjectState;
  private sessions: Map<string, object> = new Map();

  constructor(state: DurableObjectState) {
    this.state = state;
    // Load persisted state
    this.state.storage.get('sessions').then((data) => {
      if (data) this.sessions = new Map(Object.entries(data));
    });
  }

  async fetch(request: Request): Promise<Response> {
    const url = new URL(request.url);

    if (url.pathname === '/set') {
      const { key, value } = await request.json();
      this.sessions.set(key, value);
      await this.state.storage.put('sessions', Object.fromEntries(this.sessions));
      return new Response(JSON.stringify({ success: true }));
    }

    if (url.pathname === '/get') {
      const key = url.searchParams.get('key');
      return new Response(JSON.stringify(this.sessions.get(key ?? '')));
    }

    return new Response('Session Store — use /set or /get', { status: 200 });
  }
}

# wrangler.toml
[[durable_objects.bindings]]
name = "SESSION_STORE"
class_name = "SessionStore"

// From a Worker
const id = env.SESSION_STORE.idFromName('user-123-session');
const stub = env.SESSION_STORE.get(id);
const response = await stub.fetch('/get?key=lastAction');

import { Ai } from '@cloudflare/ai-utils';

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const ai = new Ai(env.AI);

    // Text generation
    const response = await ai.run('@cf/meta/llama-3-8b-instruct', {
      messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: 'Explain edge computing in one sentence.' },
      ],
      max_tokens: 128,
    });

    return c.json({ response: response.response });
  },
};

// Producer — send a job
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const body = await request.json();
    await env.EMAIL_JOURS.producer.send({
      to: body.email,
      subject: body.subject,
      body: body.message,
    });
    return c.json({ queued: true });
  },
};

// Consumer Worker — process jobs
export default {
  async queue(batch: MessageBatch, env: Env, ctx: ExecutionContext): Promise<void> {
    for (const message of batch.messages) {
      const job = message.body;
      await sendEmail(job.to, job.subject, job.body);
      message.ack();
    }
  },
};

# wrangler.toml
[[queues.consumers]]
queue = "email-jobs"
max_batch_size = 10
max_batch_timeout = 30

// Cache API (CDN)
const cache = caches.default;
let response = await cache.match(request);

if (!response) {
  response = await fetch(request);
  response = new Response(response.body, response);
  await cache.put(request, response.clone(), {
    expirationTtl: 3600,          // 1 hour TTL
    staleWhileRevalidate: 2026-05-15 86400,   // Serve stale for 24h while revalidating
  });
}