1# Durable Objects Patterns
2 
3## When to Use Which Pattern
4 
5| Need | Pattern | ID Strategy |
6|------|---------|-------------|
7| Rate limit per user/IP | Rate Limiting | `idFromName(identifier)` |
8| Mutual exclusion | Distributed Lock | `idFromName(resource)` |
9| >1K req/s throughput | Sharding | `newUniqueId()` or hash |
10| Real-time updates | WebSocket Collab | `idFromName(room)` |
11| User sessions | Session Management | `idFromName(sessionId)` |
12| Background cleanup | Alarm-based | Any |
13 
14## RPC vs fetch()
15 
16**RPC** (compat ≥2024-04-03): Type-safe, simpler, default for new projects  
17**fetch()**: Legacy compat, HTTP semantics, proxying
18 
19```typescript
20const count = await stub.increment();  // RPC
21const count = await (await stub.fetch(req)).json();  // fetch()
22```
23 
24## Sharding (High Throughput)
25 
26Single DO ~1K req/s max. Shard for higher throughput:
27 
28```typescript
29export default {
30  async fetch(req: Request, env: Env): Promise<Response> {
31    const userId = new URL(req.url).searchParams.get("user");
32    const hash = hashCode(userId) % 100;  // 100 shards
33    const id = env.COUNTER.idFromName(`shard:${hash}`);
34    return env.COUNTER.get(id).fetch(req);
35  }
36};
37 
38function hashCode(str: string): number {
39  let hash = 0;
40  for (let i = 0; i < str.length; i++) hash = ((hash << 5) - hash) + str.charCodeAt(i);
41  return Math.abs(hash);
42}
43```
44 
45**Decisions:**
46- **Shard count**: 10-1000 typical (start with 100, measure, adjust)
47- **Shard key**: User ID, IP, session - must distribute evenly (use hash)
48- **Aggregation**: Coordinator DO or external system (D1, R2)
49 
50## Rate Limiting
51 
52```typescript
53async checkLimit(key: string, limit: number, windowMs: number): Promise<boolean> {
54  const req = this.ctx.storage.sql.exec("SELECT COUNT(*) as count FROM requests WHERE key = ? AND timestamp > ?", key, Date.now() - windowMs).one();
55  if (req.count >= limit) return false;
56  this.ctx.storage.sql.exec("INSERT INTO requests (key, timestamp) VALUES (?, ?)", key, Date.now());
57  return true;
58}
59```
60 
61## Distributed Lock
62 
63```typescript
64private held = false;
65async acquire(timeoutMs = 5000): Promise<boolean> {
66  if (this.held) return false;
67  this.held = true;
68  await this.ctx.storage.setAlarm(Date.now() + timeoutMs);
69  return true;
70}
71async release() { this.held = false; await this.ctx.storage.deleteAlarm(); }
72async alarm() { this.held = false; }  // Auto-release on timeout
73```
74 
75## Hibernation-Aware Pattern
76 
77Preserve state across hibernation:
78 
79```typescript
80async fetch(req: Request): Promise<Response> {
81  const [client, server] = Object.values(new WebSocketPair());
82  const userId = new URL(req.url).searchParams.get("user");
83  server.serializeAttachment({ userId });  // Survives hibernation
84  this.ctx.acceptWebSocket(server, ["room:lobby"]);
85  server.send(JSON.stringify({ type: "init", state: this.ctx.storage.kv.get("state") }));
86  return new Response(null, { status: 101, webSocket: client });
87}
88 
89async webSocketMessage(ws: WebSocket, msg: string) {
90  const { userId } = ws.deserializeAttachment();  // Retrieve after wake
91  const state = this.ctx.storage.kv.get("state") || {};
92  state[userId] = JSON.parse(msg);
93  this.ctx.storage.kv.put("state", state);
94  for (const c of this.ctx.getWebSockets("room:lobby")) c.send(msg);
95}
96```
97 
98## Real-time Collaboration
99 
100Broadcast updates to all connected clients:
101 
102```typescript
103async webSocketMessage(ws: WebSocket, msg: string) {
104  const data = JSON.parse(msg);
105  this.ctx.storage.kv.put("doc", data.content);  // Persist
106  for (const c of this.ctx.getWebSockets()) if (c !== ws) c.send(msg);  // Broadcast
107}
108```
109 
110### WebSocket Reconnection
111 
112**Client-side** (exponential backoff):
113```typescript
114class ResilientWS {
115  private delay = 1000;
116  connect(url: string) {
117    const ws = new WebSocket(url);
118    ws.onclose = () => setTimeout(() => {
119      this.connect(url);
120      this.delay = Math.min(this.delay * 2, 30000);
121    }, this.delay);
122  }
123}
124```
125 
126**Server-side** (cleanup on close):
127```typescript
128async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean) {
129  const { userId } = ws.deserializeAttachment();
130  this.ctx.storage.sql.exec("UPDATE users SET online = false WHERE id = ?", userId);
131  for (const c of this.ctx.getWebSockets()) c.send(JSON.stringify({ type: "user_left", userId }));
132}
133```
134 
135## Session Management
136 
137```typescript
138async createSession(userId: string, data: object): Promise<string> {
139  const id = crypto.randomUUID(), exp = Date.now() + 86400000;
140  this.ctx.storage.sql.exec("INSERT INTO sessions VALUES (?, ?, ?, ?)", id, userId, JSON.stringify(data), exp);
141  await this.ctx.storage.setAlarm(exp);
142  return id;
143}
144 
145async getSession(id: string): Promise<object | null> {
146  const row = this.ctx.storage.sql.exec("SELECT data FROM sessions WHERE id = ? AND expires_at > ?", id, Date.now()).one();
147  return row ? JSON.parse(row.data) : null;
148}
149 
150async alarm() { this.ctx.storage.sql.exec("DELETE FROM sessions WHERE expires_at <= ?", Date.now()); }
151```
152 
153## Multiple Events (Single Alarm)
154 
155Queue pattern to schedule multiple events:
156 
157```typescript
158async scheduleEvent(id: string, runAt: number) {
159  await this.ctx.storage.put(`event:${id}`, { id, runAt });
160  const curr = await this.ctx.storage.getAlarm();
161  if (!curr || runAt < curr) await this.ctx.storage.setAlarm(runAt);
162}
163 
164async alarm() {
165  const events = await this.ctx.storage.list({ prefix: "event:" }), now = Date.now();
166  let next = null;
167  for (const [key, ev] of events) {
168    if (ev.runAt <= now) {
169      await this.processEvent(ev);
170      await this.ctx.storage.delete(key);
171    } else if (!next || ev.runAt < next) next = ev.runAt;
172  }
173  if (next) await this.ctx.storage.setAlarm(next);
174}
175```
176 
177## Graceful Cleanup
178 
179Use `ctx.waitUntil()` to complete work after response:
180 
181```typescript
182async myMethod() {
183  const response = { success: true };
184  this.ctx.waitUntil(this.ctx.storage.sql.exec("DELETE FROM old_data WHERE timestamp < ?", cutoff));
185  return response;
186}
187```
188 
189## Best Practices
190 
191- **Design**: Use `idFromName()` for coordination, `newUniqueId()` for sharding, minimize constructor work
192- **Storage**: Prefer SQLite, batch with transactions, set alarms for cleanup, use PITR before risky ops
193- **Performance**: ~1K req/s per DO max - shard for more, cache in memory, use alarms for deferred work
194- **Reliability**: Handle 503 with retry+backoff, design for cold starts, test migrations with `--dry-run`
195- **Security**: Validate inputs in Workers, rate limit DO creation, use jurisdiction for compliance
196 
197## See Also
198 
199- **[API](./api.md)** - ctx methods, WebSocket handlers
200- **[Gotchas](./gotchas.md)** - Hibernation caveats, common errors
201- **[DO Storage](../do-storage/README.md)** - Storage patterns and transactions
202