Starter example Bindings

A small Durable Objects example you can adapt quickly

This example uses a tiny counter object because the shape is easy to understand and still proves the important DO wiring.

A counter is not glamorous, but it teaches the real ingredients: one binding, one class, one namespace lookup, and one request path that exercises state.

Config focus: Explicit class discovery and DO binding
Runtime shape: Namespace lookup plus
Best use: Counters, room state, and small single-identity coordination examples

Start by wiring the binding clearly in config

Minimal Durable Object config

import { defineConfig } from 'devflare/config'

export default defineConfig({

name: 'do-example',

files: {

fetch: 'src/fetch.ts',

durableObjects: 'src/do/**/*.ts'

bindings: {

durableObjects: {

COUNTER: 'Counter'

}

migrations: [

{

tag: 'v1',

new_classes: ['Counter']

}

]

})

Then use it in one honest runtime path

This tiny shape already proves that the object class, namespace, and fetch path are wired correctly.
Once this works, richer room or lock logic becomes a normal extension instead of a blind leap.

A tiny object and fetch path

import { env } from 'devflare'

// src/do/counter.ts should increment a stored value and return the new count.

export async function fetch(): Promise<Response> {

const id = env.COUNTER.idFromName('global')

const stub = env.COUNTER.get(id)

return stub.fetch('https://counter/increment')

}

Lock in the behavior with one small test or smoke path

The tiny state machine is enough

You do not need a chat app to learn Durable Objects. One counter proves the important mechanics without burying them.

A matching local test

import { afterAll, beforeAll, expect, test } from 'bun:test'

import { createTestContext, cf } from 'devflare/test'

import { env } from 'devflare'

beforeAll(() => createTestContext())

afterAll(() => env.dispose())

test('GET / increments the counter object', async () => {

const first = await cf.worker.get('/')

const second = await cf.worker.get('/')

expect(await first.text()).toBe('1')

expect(await second.text()).toBe('2')

})

Testing Durable Objects

Durable Objects are well-supported in the default Devflare harness, which means you can test real object behavior without hand-building a fake namespace first.

Queues

Devflare models Queue producers and consumers explicitly, which makes local tests and preview naming much easier to reason about.