Durable Objects example about worktop HOT 2 CLOSED

// Counter DO class
import { Router } from 'worktop'
import { reply } from 'worktop/response'
import { Actor } from 'worktop/cfw.durable'

import type { Durable } from 'worktop/cfw.durable'
import type { WebSocket } from 'worktop/cfw.ws'

type Connection = {
  ws: WebSocket
}

function replyWS(socket: WebSocket, type: string, data: number | string) {
  let message = JSON.stringify({ type, data })
  socket.send(message)
}

export class Counter extends Actor {
  count: number
  API = this.router()
  connections: Connection[] = []
  storage: Durable.Storage

  async setup(state: Durable.State, bindings: Bindings) {
    this.count = (await state.storage.get(`count`)) || 0
    this.storage = state.storage
  }

  receive = this.API.run

  onconnect = (req: Request, server: WebSocket) => {
    this.connections.push({ ws: server })

    server.addEventListener(`message`, this.handleMessage)
    server.addEventListener(`close`, this.handleCloseOrError)
    server.addEventListener(`error`, this.handleCloseOrError)

    replyWS(server, `count/LOADED`, this.count)
  }

  router() {
    const API = new Router()

    API.add(`GET`, `/`, () => {
      return reply(200, this.count)
    })

    API.add(`GET`, `/ws`, async (req) => {
      const res = await this.connect(req)
      return res
    })

    return API
  }

  broadcast() {
    this.connections.forEach((client) => {
      try {
        replyWS(client.ws, `count/UPDATED`, this.count)
      } catch (err) {}
    })
  }

  handleMessage = async (e) => {
    try {
      const event = JSON.parse(e.data)

      switch (event.type) {
        case 'increment':
          await this.storage.put('count', ++this.count)
          break

        case 'decrement':
          await this.storage.put('count', --this.count)
          break

        default:
          break
      }

      this.broadcast()
    } catch (err) {}
  }

  handleCloseOrError = (e) => {
    this.connections = this.connections.filter(({ ws }) => ws !== e.target)
  }
}

function requestFromCounterDO(req, ctx) {
  const { id } = ctx.params

  const url = new URL(req.url)

  // /room/1/ => '/'
  // /room/1/ws -> /ws
  // matches DO class router
  url.pathname = url.pathname.replace(`/room/${id}`, ``)

  // get a specific durable object based on room id
  const namespace = ctx.bindings.COUNTER
  const objectId = namespace.idFromName(id)
  const object = namespace.get(objectId)

  return object.fetch(url, req)
}

// REST endpoint
API.add('GET', '/room/:id/', requestFromCounterDO)

// ws endpoint
API.add('GET', '/room/:id/ws', requestFromCounterDO)