Workers

import type { DurableObject, DurableObjectState, DurableObjectEnv } from '@dotdo/types/workers'

class Counter implements DurableObject {
  private state: DurableObjectState
  private value: number = 0

  constructor(state: DurableObjectState, env: DurableObjectEnv) {
    this.state = state
    // Restore state from storage
    state.blockConcurrencyWhile(async () => {
      this.value = (await state.storage.get('value')) ?? 0
    })
  }

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

    if (url.pathname === '/increment') {
      this.value++
      await this.state.storage.put('value', this.value)
    }

    return Response.json({ value: this.value })
  }
}

import type { DurableObjectId, DurableObjectNamespace, DurableObjectStub } from '@dotdo/types/workers'

// Get a namespace from the environment
const namespace: DurableObjectNamespace = env.COUNTER

// Create an ID from a name (deterministic)
const id: DurableObjectId = namespace.idFromName('user-123-counter')

// Create a new unique ID
const newId: DurableObjectId = namespace.newUniqueId()

// Parse an ID from a string
const parsedId: DurableObjectId = namespace.idFromString('abc123...')

// Get a stub to interact with the object
const stub: DurableObjectStub = namespace.get(id)

// Call the object
const response = await stub.fetch('/increment')
const data = await response.json()

import type { DurableObjectStorage, DurableObjectStorageValue } from '@dotdo/types/workers'

class UserSession implements DurableObject {
  private storage: DurableObjectStorage

  constructor(state: DurableObjectState) {
    this.storage = state.storage
  }

  async login(userId: string) {
    // Store a single value
    await this.storage.put('userId', userId)
    await this.storage.put('loginAt', Date.now())

    // Store multiple values atomically
    await this.storage.put({
      userId,
      loginAt: Date.now(),
      active: true
    })
  }

  async getSession() {
    // Get a single value
    const userId = await this.storage.get<string>('userId')

    // Get multiple values
    const data = await this.storage.get(['userId', 'loginAt', 'active'])

    // List all values with a prefix
    const userData = await this.storage.list({ prefix: 'user:' })

    return { userId, data: Object.fromEntries(userData) }
  }

  async logout() {
    // Delete a single key
    await this.storage.delete('active')

    // Delete multiple keys
    await this.storage.delete(['userId', 'loginAt', 'active'])

    // Delete all keys with a prefix
    await this.storage.deleteAll()
  }
}

import type { DurableObjectTransaction } from '@dotdo/types/workers'

await state.storage.transaction(async (txn: DurableObjectTransaction) => {
  const balance = await txn.get<number>('balance') ?? 0

  if (balance < amount) {
    // Transaction will be aborted
    throw new Error('Insufficient balance')
  }

  await txn.put('balance', balance - amount)
  await txn.put('lastTransaction', {
    type: 'withdrawal',
    amount,
    timestamp: Date.now()
  })
})

import type { DOState, DOTransaction, DOStateListOptions } from '@dotdo/types/workers'

interface UserState {
  name: string
  email: string
  loginCount: number
  lastLoginAt: number
  preferences: Record<string, unknown>
}

class UserDO implements DurableObject {
  private state: DOState<UserState>

  constructor(doState: DurableObjectState) {
    this.state = createDOState<UserState>(doState.storage)
  }

  async login() {
    // Typed get - returns string | undefined
    const name = await this.state.get('name')

    // Typed put - type-checked value
    await this.state.put('loginCount', (await this.state.get('loginCount') ?? 0) + 1)
    await this.state.put('lastLoginAt', Date.now())
  }

  async updateProfile(updates: Partial<UserState>) {
    // Put multiple values
    await this.state.putAll(updates)
  }

  async getAll(): Promise<Partial<UserState>> {
    // Get all state as a partial object
    return await this.state.getAll()
  }
}

import type { DOTransaction } from '@dotdo/types/workers'

const result = await this.state.transaction(async (txn: DOTransaction<UserState>) => {
  const balance = (await txn.get('credits')) ?? 0

  if (balance < cost) {
    txn.rollback() // Aborts and throws
  }

  await txn.put('credits', balance - cost)
  await txn.put('lastPurchaseAt', Date.now())

  return { newBalance: balance - cost }
})

import type { DOAlarm, DOAlarmOptions, AlarmEvent } from '@dotdo/types/workers'

class ReminderDO implements DurableObject {
  private alarm: DOAlarm

  constructor(state: DurableObjectState) {
    this.alarm = createDOAlarm(state)
  }

  async scheduleReminder(delayMs: number) {
    // Set an alarm
    await this.alarm.setAlarm(Date.now() + delayMs)

    // Or with a Date
    await this.alarm.setAlarm(new Date('2024-12-31T23:59:59Z'))
  }

  async alarm() {
    // This method is called when the alarm fires
    await this.sendReminder()

    // Check if there's more work
    const nextReminder = await this.getNextReminderTime()
    if (nextReminder) {
      await this.alarm.setAlarm(nextReminder)
    }
  }

  async cancelReminder() {
    await this.alarm.deleteAlarm()
  }

  async getStatus() {
    const scheduled = await this.alarm.getAlarm()
    const hasAlarm = await this.alarm.hasAlarm()
    const remaining = await this.alarm.getTimeRemaining()

    return { scheduled, hasAlarm, remaining }
  }
}

import type { WebSocketState, WebSocketHandlers } from '@dotdo/types/workers'

class ChatRoom implements DurableObject {
  private sessions: Map<WebSocket, WebSocketState> = new Map()

  async fetch(request: Request): Promise<Response> {
    if (request.headers.get('Upgrade') === 'websocket') {
      const [client, server] = Object.values(new WebSocketPair())

      // Accept with hibernation support
      this.state.acceptWebSocket(server, ['chatroom'])

      // Attach user data that survives hibernation
      server.serializeAttachment({ userId: 'user_123', joinedAt: Date.now() })

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

    return new Response('Expected WebSocket', { status: 400 })
  }

  // Called after hibernation wake-up
  async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
    // Retrieve attached data
    const state = ws.deserializeAttachment<{ userId: string; joinedAt: number }>()
    console.log(`Message from ${state?.userId}:`, message)

    // Broadcast to all connected clients
    for (const client of this.state.getWebSockets()) {
      if (client !== ws) {
        client.send(message)
      }
    }
  }

  async webSocketClose(ws: WebSocket, code: number, reason: string) {
    const state = ws.deserializeAttachment<{ userId: string }>()
    console.log(`User ${state?.userId} disconnected: ${code} ${reason}`)
  }

  async webSocketError(ws: WebSocket, error: Error) {
    console.error('WebSocket error:', error)
  }
}

import type { HibernationConfig, HibernationState, HibernationMetrics } from '@dotdo/types/workers'

const config: HibernationConfig = {
  // Auto-respond to pings without waking
  autoResponseMessage: {
    request: 'ping',
    response: 'pong'
  },

  // Hibernate after 60 seconds of inactivity
  idleTimeout: 60000,

  // Maximum hibernation duration
  maxHibernationDuration: 24 * 60 * 60 * 1000, // 24 hours

  // Preserve in-memory state through hibernation
  preserveState: true,

  // Hooks
  onHibernate: async () => {
    console.log('Going to sleep...')
  },
  onWake: async () => {
    console.log('Waking up!')
  },

  // WebSocket tags for selective wake-up
  webSocketTags: ['chatroom', 'admin']
}

import type { HibernationMetrics } from '@dotdo/types/workers'

const metrics: HibernationMetrics = {
  totalHibernationTime: 3600000,      // 1 hour in ms
  hibernationCount: 50,                // Times hibernated
  wakeCount: 48,                       // Times woken
  averageHibernationDuration: 72000,   // 72 seconds average
  autoResponseCount: 1000,             // Pings handled while sleeping
  lastHibernatedAt: 1705312800000,
  lastWokenAt: 1705312860000
}

import type { DurableObjectSqlStorage } from '@dotdo/types/workers'

class AnalyticsDO implements DurableObject {
  private sql: DurableObjectSqlStorage

  constructor(state: DurableObjectState) {
    this.sql = state.storage.sql
  }

  async initialize() {
    // Create tables
    await this.sql.exec(`
      CREATE TABLE IF NOT EXISTS events (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        type TEXT NOT NULL,
        data TEXT,
        created_at INTEGER DEFAULT (unixepoch())
      )
    `)

    await this.sql.exec(`
      CREATE INDEX IF NOT EXISTS idx_events_type ON events(type)
    `)
  }

  async recordEvent(type: string, data: unknown) {
    await this.sql.exec(
      'INSERT INTO events (type, data) VALUES (?, ?)',
      type,
      JSON.stringify(data)
    )
  }

  async getEventsByType(type: string) {
    const cursor = this.sql.exec(
      'SELECT * FROM events WHERE type = ? ORDER BY created_at DESC LIMIT 100',
      type
    )

    const events = []
    for (const row of cursor) {
      events.push({
        id: row.id,
        type: row.type,
        data: JSON.parse(row.data as string),
        createdAt: row.created_at
      })
    }
    return events
  }

  async getStats() {
    const cursor = this.sql.exec(`
      SELECT type, COUNT(*) as count
      FROM events
      GROUP BY type
      ORDER BY count DESC
    `)

    return Array.from(cursor).map(row => ({
      type: row.type,
      count: row.count
    }))
  }
}

import type { DurableObjectRequestContext } from '@dotdo/types/workers'

class MyDO implements DurableObject {
  async fetch(request: Request): Promise<Response> {
    // Access request metadata
    const url = new URL(request.url)
    const method = request.method
    const headers = request.headers

    // Handle different paths
    switch (url.pathname) {
      case '/get':
        return this.handleGet()
      case '/set':
        return this.handleSet(await request.json())
      default:
        return new Response('Not Found', { status: 404 })
    }
  }
}