Workers Durable Objects -- Stateful Serverless

// counter.mjs
import { DurableObject } from 'cloudflare:workers';

export class Counter extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.count = 0;
  }

  async initialize() {
    const stored = await this.ctx.storage.get('count');
    this.count = stored || 0;
  }

  async increment(amount = 1) {
    this.count += amount;
    await this.ctx.storage.put('count', this.count);
    return this.count;
  }

  async getCount() {
    return this.count;
  }
}

// wrangler.toml
// [durable_objects]
// bindings = [{ name = "COUNTER", class_name = "Counter" }]
// [[migrations]]
// tag = "v1"
// new_classes = ["Counter"]

// worker.mjs
export default {
  async fetch(request, env) {
    const url = new URL(request.url);
    const id = env.COUNTER.idFromName('global-counter');
    const stub = env.COUNTER.get(id);
    await stub.initialize();

    if (url.pathname === '/increment') {
      const count = await stub.increment();
      return new Response(`Count: ${count}`);
    }

    const count = await stub.getCount();
    return new Response(`Current count: ${count}`);
  }
};

// Expected output:
// GET /increment -> "Count: 1"
// GET /increment -> "Count: 2"
// GET / -> "Current count: 2"

import { DurableObject } from 'cloudflare:workers';

export class ChatRoom extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.sessions = new Map();
    ctx.setWebSocketAutoResponse(
      new Response(null, { status: 101 })
    );
  }

  async fetch(request) {
    const pair = new WebSocketPair();
    const [client, server] = Object.values(pair);

    this.ctx.acceptWebSocket(server);
    this.sessions.set(server, { joinedAt: Date.now() });

    server.addEventListener('message', (event) => {
      const msg = JSON.parse(event.data);
      for (const ws of this.sessions.keys()) {
        if (ws !== server) {
          ws.send(JSON.stringify({
            user: msg.user,
            text: msg.text,
            timestamp: Date.now()
          }));
        }
      }
    });

    server.addEventListener('close', () => {
      this.sessions.delete(server);
    });

    return new Response(null, { status: 101, webSocket: client });
  }

  async alarm() {
    const count = this.sessions.size;
    for (const ws of this.sessions.keys()) {
      ws.send(JSON.stringify({ type: 'heartbeat', activeUsers: count }));
    }
    await this.ctx.storage.setAlarm(Date.now() + 30000);
  }
}

// Expected behavior:
// 1. Two clients connect via WebSocket
// 2. Client A sends {"user": "Alice", "text": "Hello!"}
// 3. Client B receives {"user": "Alice", "text": "Hello!", "timestamp": ...}
// 4. Every 30 seconds, both receive a heartbeat with active user count

import { DurableObject } from 'cloudflare:workers';

export class RateLimiter extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.windows = new Map();
  }

  async check(key, maxRequests, windowSeconds) {
    const now = Math.floor(Date.now() / 1000);
    const windowKey = `${key}:${Math.floor(now / windowSeconds)}`;
    const current = this.windows.get(windowKey) || 0;

    if (current >= maxRequests) {
      return { allowed: false, remaining: 0, resetIn: windowSeconds };
    }

    this.windows.set(windowKey, current + 1);
    setTimeout(() => this.windows.delete(windowKey), windowSeconds * 1000);
    return { allowed: true, remaining: maxRequests - current - 1, resetIn: windowSeconds };
  }
}

// Worker usage
export default {
  async fetch(request, env) {
    const ip = request.headers.get('CF-Connecting-IP');
    const id = env.LIMITER.idFromName('global-limiter');
    const stub = env.LIMITER.get(id);
    const result = await stub.check(ip, 100, 60);

    if (!result.allowed) {
      return new Response('Rate limit exceeded', { status: 429 });
    }

    return new Response('OK');
  }
};

// Expected output:
// 100th request from same IP within 60s -> "OK"
// 101st request from same IP within 60s -> "Rate limit exceeded" (429)