01
// cloudflare:workers 是 Cloudflare Workers 的内置模块，不是 npm 包
02
import { DurableObject } from 'cloudflare:workers'
03

04
export class Counter extends DurableObject {
05
  async increment(): Promise<number> {
06
    // ctx.storage 是这个 Object 独占的强一致存储
07
    const current = (await this.ctx.storage.get<number>('count')) ?? 0
08
    const next = current + 1
09
    await this.ctx.storage.put('count', next)
10
    return next
11
  }
12

13
  async get(): Promise<number> {
14
    return (await this.ctx.storage.get<number>('count')) ?? 0
15
  }
16
}

01
import { Hono } from 'hono'
02
import { Counter } from './rooms'
03

04
type Bindings = {
05
  COUNTER: DurableObjectNamespace<Counter>  // Workers 内置类型，不需要 import
06
}
07

08
const app = new Hono<{ Bindings: Bindings }>()
09

10
app.post('/rooms/:roomId/click', async (c) => {
11
  const roomId = c.req.param('roomId')
12

13
  // 1. 从 roomId 得到一个稳定的 DO ID
14
  const id = c.env.COUNTER.idFromName(roomId)
15
  // 2. 拿到这个 DO 的 stub（可以理解成远程引用）
16
  const stub = c.env.COUNTER.get(id)
17
  // 3. 调用它的方法，和调用本地对象一样
18
  const count = await stub.increment()
19

20
  return c.json({ roomId, count })
21
})
22

23
app.get('/rooms/:roomId/count', async (c) => {
24
  const roomId = c.req.param('roomId')
25
  const stub = c.env.COUNTER.get(c.env.COUNTER.idFromName(roomId))
26
  const count = await stub.get()
27
  return c.json({ roomId, count })
28
})
29

30
// 必须 export DO 类，Workers 运行时才认得
31
export { Counter }
32
export default app

01
import { DurableObject } from 'cloudflare:workers'
02

03
type Env = { AI: Ai }
04

05
interface ChatMessage {
06
  role: 'user' | 'assistant'
07
  content: string
08
}
09

10
export class ChatRoom extends DurableObject<Env> {
11
  async fetch(request: Request): Promise<Response> {
12
    // 1. 必须是 WebSocket upgrade 请求
13
    if (request.headers.get('Upgrade') !== 'websocket') {
14
      return new Response('Expected WebSocket', { status: 426 })
15
    }
16

17
    // 2. 创建一对 WebSocket
18
    const pair = new WebSocketPair()
19
    const [client, server] = Object.values(pair)
20

21
    // 3. Hibernatable 模式接收服务端一侧
22
    this.ctx.acceptWebSocket(server)
23

24
    // 4. 返回客户端一侧给上游
25
    return new Response(null, { status: 101, webSocket: client })
26
  }
27

28
  // Hibernatable 版本的消息处理器（注意不是 addEventListener）
29
  async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
30
    if (typeof message !== 'string') return
31

32
    const userMsg: ChatMessage = { role: 'user', content: message }
33

34
    // 取出历史消息
35
    const history = (await this.ctx.storage.get<ChatMessage[]>('history')) ?? []
36
    history.push(userMsg)
37

38
    // 调 LLM
39
    const result = await this.env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
40
      messages: history,
41
    })
42

43
    // Workers AI 文本生成返回 { response: string }，类型声明比较宽泛所以要断言一下
44
    const assistantMsg: ChatMessage = {
45
      role: 'assistant',
46
      content: (result as { response: string }).response,
47
    }
48
    history.push(assistantMsg)
49

50
    // 保存历史
51
    await this.ctx.storage.put('history', history)
52

53
    // 把回答推给客户端
54
    ws.send(JSON.stringify(assistantMsg))
55
  }
56

57
  async webSocketClose(ws: WebSocket, code: number) {
58
    // 连接关闭时的清理逻辑
59
    console.log(`WebSocket closed with code ${code}`)
60
  }
61
}

01
import { Hono } from 'hono'
02
import { ChatRoom } from './chat-room'
03

04
type Bindings = {
05
  CHAT_ROOM: DurableObjectNamespace<ChatRoom>
06
  AI: Ai
07
}
08

09
const app = new Hono<{ Bindings: Bindings }>()
10

11
app.get('/chat/:userId', async (c) => {
12
  // 每个用户一个独立的 ChatRoom
13
  const userId = c.req.param('userId')
14
  const id = c.env.CHAT_ROOM.idFromName(userId)
15
  const stub = c.env.CHAT_ROOM.get(id)
16

17
  // 把 upgrade 请求直接转给 DO，DO 自己处理 101 响应
18
  return stub.fetch(c.req.raw)
19
})
20

21
export { ChatRoom }
22
export default app

1
const ws = new WebSocket('wss://your-worker.workers.dev/chat/alice')
2

3
ws.onmessage = (e) => {
4
  const msg = JSON.parse(e.data)
5
  console.log('AI:', msg.content)
6
}
7

8
ws.send('你好，介绍一下 Cloudflare Workers')

01
import { DurableObject } from 'cloudflare:workers'
02

03
type Env = { AI: Ai }
04

05
export class MeetingRoom extends DurableObject<Env> {
06
  async fetch(request: Request): Promise<Response> {
07
    const url = new URL(request.url)
08
    const username = url.searchParams.get('user') ?? 'anon'
09

10
    const pair = new WebSocketPair()
11
    const [client, server] = Object.values(pair)
12

13
    // serializeAttachment 把数据附加到这个连接上
14
    // DO 休眠再唤醒后，用 deserializeAttachment 能拿回来
15
    server.serializeAttachment({ username })
16

17
    this.ctx.acceptWebSocket(server)
18

19
    return new Response(null, { status: 101, webSocket: client })
20
  }
21

22
  async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
23
    if (typeof message !== 'string') return
24

25
    const { username } = ws.deserializeAttachment() as { username: string }
26
    const payload = JSON.stringify({ from: username, text: message })
27

28
    // 广播给房间里所有其他连接
29
    for (const client of this.ctx.getWebSockets()) {
30
      if (client === ws) continue
31
      try {
32
        client.send(payload)
33
      } catch {
34
        // 客户端掉线时可能报错，忽略即可
35
      }
36
    }
37
  }
38
}

01
export class ChatRoom extends DurableObject<Env> {
02
  async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
03
    // ... 处理消息 ...
04

05
    // 每次有消息，就把「闹钟」推到 30 分钟后
06
    await this.ctx.storage.setAlarm(Date.now() + 30 * 60 * 1000)
07
  }
08

09
  async alarm() {
10
    // 30 分钟没消息了，归档历史并重置
11
    const history = await this.ctx.storage.get('history')
12
    if (history) {
13
      await archiveToR2(history)  // 保存到 R2
14
      await this.ctx.storage.delete('history')
15
    }
16
  }
17
}