On Durable Objects

export default {
  async fetch(request, env) {
    const id1 = env.OBJECT.idFromName("test");

    const stub1 = env.OBJECT.get(id1);
    const stub2 = env.OBJECT.get(id1);
    const stub3 = env.OBJECT.get(id1);

    const res1 = await stub1.fetch(request); // constructor called
    const res2 = await stub2.fetch(request);
    const res3 = await stub3.fetch(request);
    return res1
  }
}

// the DO class
export class MyDO extends DurableObject {
  async fetch(request) {
    const res = await fetch("https://www.cloudflare.com/cdn-cgi/trace");
    const data = await res.text();
    return new Response(data);
  }
}

// use the worker to return the DO’s reported information
export default {
  async fetch(request, env) {
    const id = env.MY_DO.idFromName("test");
    const stub = env.MY_DO.get(id, { locationHint: "enam" });
    const objectResponse = await stub.fetch(request);
    const text = await objectResponse.text();
    return new Response(text);
  }
}

sequenceDiagram
  actor User
  participant WorkerA
  participant DO_NAMESPACE
  participant DO
  participant WorkerB
  User->>WorkerA: write
  activate User
  WorkerA->>DO_NAMESPACE: `newUniqueId()`
  DO_NAMESPACE->>WorkerA: <ID>
  WorkerA->>DO: write
  activate DO
  DO->>WorkerA: OK
  WorkerA->>User: OK + Use this <string(ID)> for strong reads
  deactivate User
  User->>WorkerB: Read w/ <string(ID)>
  activate User
  WorkerB->>DO_NAMESPACE: `idFromString(<string(ID)>)`
  DO_NAMESPACE->>WorkerB: previous <ID>
  WorkerB->>DO: read
  DO->>WorkerB: OK
  WorkerB->>User: OK, result that WorkerA wrote
  deactivate User
  deactivate DO

import { describe, bench, BenchOptions } from 'vitest';
import { Miniflare } from 'miniflare';

const basic = new Miniflare({
  modules: true,
  durableObjectsPersist: false,
  script: `
    export class DurableObject {
      async fetch(request) {
        return new Response("Hello Miniflare!");
      }
    }
    export default {
      fetch(request) {
        return new Response("Hello Miniflare!");
      }
    }
    `,
  durableObjects: {
    OBJECT: 'DurableObject',
  },
});

const doFetch = new Miniflare({
  modules: true,
  durableObjectsPersist: false,
  script: `
    export class DurableObject {
      async fetch(request) {
        return new Response("Hello Miniflare!");
      }
    }
    export default {
      fetch(request, env) {
        const stub = env.OBJECT.get(env.OBJECT.idFromName("test"));
        return stub.fetch(request);
      }
    }
    `,
  durableObjects: {
    OBJECT: 'DurableObject',
  },
});

const doInc = new Miniflare({
  modules: true,
  durableObjectsPersist: false,
  script: `
    export class DurableObject {
      count = 0;

      constructor(state, env) {
        this.state = state
        state.blockConcurrencyWhile(async () => {
          this.count = (await state.storage.get('count')) ?? 0;
        });
      }

      increment(by = 1) {
        this.count += by;
        void this.state.storage.put('count', this.count);
      }

      async fetch(request) {
        this.increment()
        return new Response("Hello Do "+this.count);
      }
    }
    export default {
      fetch(request, env) {
        const stub = env.OBJECT.get(env.OBJECT.idFromName("test"));
        return stub.fetch(request);
      }
    }
    `,
  durableObjects: {
    OBJECT: 'DurableObject',
  },
});

const doInitUnoptimized = new Miniflare({
  modules: true,
  durableObjectsPersist: false,
  script: `
    export class DurableObject {
      list = []

      constructor(state, env) {
        console.log("constructor called")
        this.state = state
        this.env = env
      }

      async fetch(request) {
        return new Response("Hello Do "+this.list);
      }
    }
    export default {
      async fetch(request, env) {
        const id1 = env.OBJECT.idFromName("test");
        const stub1 = env.OBJECT.get(id1);
        const stub2 = env.OBJECT.get(id1);
        const stub3 = env.OBJECT.get(id1);
        const res1 = await stub1.fetch(request);
        const res2 = await stub2.fetch(request);
        const res3 = await stub3.fetch(request);
        return new res1
      }
    }
    `,
  durableObjects: {
    OBJECT: 'DurableObject',
  },
});

const doInitSleep = new Miniflare({
  modules: true,
  durableObjectsPersist: false,
  script: `
    export class DurableObject {
      list = []

      constructor(state, env) {
        console.log("constructor called")
        this.state = state
        this.env = env

        this.state.blockConcurrencyWhile(async () => {
          // get previous value
          let stored = await this.state.storage.get('list')
          // await new Promise(r => setTimeout(r, 2000));
          this.list = this.list.concat(stored)
          // this.list = this.list.concat('a')
          // await this.state.storage.put('list', this.list)
        })
      }

      async fetch(request) {
        // this.list = this.list.concat('a')
        // await this.state.storage.put('list', this.list)
        await this.state.storage.put('list', ['b'])
        return new Response("Hello Do "+this.list);
      }
    }
    export default {
      async fetch(request, env) {
        const id1 = env.OBJECT.idFromName("test");
        const stub1 = env.OBJECT.get(id1);
        const stub2 = env.OBJECT.get(id1);
        const stub3 = env.OBJECT.get(id1);
        const res1 = await stub1.fetch(request);
        const res2 = await stub2.fetch(request);
        const res3 = await stub3.fetch(request);
        return res1
      }
    }
    `,
  durableObjects: {
    OBJECT: 'DurableObject',
  },
});

describe('DO benchmarks', () => {
  let opts = {
    time: 500,
    warmupIterations: 100,
  } satisfies BenchOptions;

  bench(
    'doFetch',
    async () => {
      const res = await doFetch.dispatchFetch('http://localhost:8787/');
      await res.text();
    },
    opts,
  );

  bench(
    'doInc',
    async () => {
      const res = await doInc.dispatchFetch('http://localhost:8787/');
      await res.text();
    },
    opts,
  );

  bench(
    'basic',
    async () => {
      const res = await basic.dispatchFetch('http://localhost:8787/');
      await res.text();
    },
    opts,
  );

  bench(
    'doInitUnoptimized',
    async () => {
      const res = await doInitUnoptimized.dispatchFetch('http://localhost:8787/');
      await res.text();
    },
    opts,
  );

  bench.only(
    'doInitSleep',
    async () => {
      const res = await doInitSleep.dispatchFetch('http://localhost:8787/');
      console.log(await res.text());
    },
    opts,
  );
});

kevin:~ $ npx vitest bench
✓ benchmarks/foo.bench.ts (5) 3097ms
   ✓ DO benchmarks (5) 3082ms
     name                     hz     min      max    mean     p75     p99    p995     p999     rme  samples
   · doFetch            1,373.09  0.4368   2.7639  0.7283  0.7884  2.4284  2.6813   2.7639  ±2.92%      687
   · doInc              1,511.96  0.4210   2.7437  0.6614  0.7210  2.1804  2.4600   2.7437  ±2.89%      756
   · basic              2,391.29  0.2648   9.3051  0.4182  0.4328  1.8612  2.1272   2.3522  ±4.54%     1196   fastest
   · doInitUnoptimized  1,459.09  0.4515   2.9745  0.6854  0.7325  2.2254  2.7056   2.9745  ±2.91%      731
   · doInitSleep        1,239.17  0.5139  11.0636  0.8070  0.8547  2.5680  2.7776  11.0636  ±4.98%      620   slowest


 BENCH  Summary

  basic - benchmarks/foo.bench.ts > DO benchmarks
    1.58x faster than doInc
    1.64x faster than doInitUnoptimized
    1.74x faster than doFetch
    1.93x faster than doInitSleep