sor4chi / hono-do

A wrapper of Cloudflare Workers's Durable Object for Hono.

Hono for Durable Object

Hono DO is a wrapper of Cloudflare Workers ' Durable Object, designed for Hono.

Important

Cloudflare released RPC feature, which is a better way to communicate between Durable Objects. This library was developed to improve the developer experience for Durable Objects when RPC was not yet available. So, please consider it before using this library.

$ npm install hono-do

Usage

export const Counter = generateHonoObject("/counter", async (app, state) => {
  const { storage } = state;
  let value = (await storage.get<number>("value")) ?? 0;

  app.post("/increment", (c) => {
    storage.put("value", value++);
    return c.text(value.toString());
  });

  app.post("/decrement", (c) => {
    storage.put("value", value--);
    return c.text(value.toString());
  });

  app.get("/", (c) => {
    return c.text(value.toString());
  });
});

You want to find more? Check out the examples!

Support

• Alarm API
• Hibernation Websocket API

License

MIT

Contributing

This project is open for contributions. Feel free to open an issue or a pull request! Contributing Guide for more information.

hono-do's Issues

Question: Is this project still maintained?

Hi @sor4chi! Thanks for creating this package. It is exciting.

I notice that it hasn't been maintained in some time. Are you still planning on keeping it?

I intend to help you maintain it; I guess my question is if you are interested in active work on it or if I should focus on my fork.

Best regard!

Durable Objects syntax idea

Durable Object is a very good representation in that it can store state and mutations as a single object.
However, if we could provide a third party, we would be able to ensure more flexibility and maintainability of notation.

ref: honojs/examples#86

For now, I implemented the simplest method I can think of at the moment to generate a HonoObject in main and a sample of it.

As far as I know, Durable Object works by exporting the class itself, not the class instance.
Therefore, we tried to use the Constructor Function to generate dynamic classes while keeping the Hono interface easy to use.

If you have any ideas for a better interface, we'd love to hear your opinions and suggestions!

WebSocket context

Hono does not have a WebSocket context function like c.ws() by default.
Because websocket implementations vary considerably from runtime to runtime.

Since Hono DO is a library specialized for cloudflare workers, we thought it would be easier to use if we extended context to provide a handler for websocket.

[BUG]: an error occur when Hono Object's basepath is dynamic path

Reproduce

const app = new Hono<{
  Bindings: {
    ROOM: DurableObjectNamespace;
  };
}>();

app.all("/room/:roomId/*", (c) => {
  const roomId = c.req.param("roomId");
  const id = c.env.ROOM.idFromName(roomId);
  const obj = c.env.ROOM.get(id);
  return obj.fetch(c.req.raw);
});

export const Room = generateHonoObject("/room/:roomId", (app) => {
  app.get("/", (c) => c.text(c.req.param("roomId")));
});

Error

Can not add a route since the matcher is already built.

Way to resolve

Currently, Hono is initialized only once outside the constructor of HonoObject.
Initialize Hono class in HonoObject's constructor.

Endpoint Integration Idea

I want to add new syntax for less code.

export const Counter = generateHonoObject("/counter", async (app, state) => {
  const { storage } = state;
  let value = (await storage.get<number>("value")) ?? 0;

  app.post("/increment", (c) => {
    storage.put("value", value++);
    return c.text(value.toString());
  });

  app.post("/decrement", (c) => {
    storage.put("value", value--);
    return c.text(value.toString());
  });

  app.get("/", (c) => {
    return c.text(value.toString());
  });
});

So far the code had to be written like this

app.all("/counter/*", (c) => {
  const id = c.env.COUNTER.idFromName("Counter");
  const obj = c.env.COUNTER.get(id);
  return obj.fetch(c.req.raw);
});

I plan to add a new syntax like

app.do(Counter, "Counter")

app.do() is extended by Hono. The first args is Hono Object, and The second args is the value of idFromName().

How can a client (web browser) connect direct to Durable object via websocket

How can a client (web browser) connect direct to Durable object via websocket+hono?

Add tests

https://developers.cloudflare.com/durable-objects/examples/testing-with-durable-objects/

Cloudflare Pages example

All of the examples are based on workers, so want to add some Cloudflare Pages examples.

Alarm support

https://developers.cloudflare.com/durable-objects/api/alarms-in-durable-objects/

Having issues making messages persist

@sor4chi Thank you so much for making hono-do library. It makes it so easy to work with DO and websockets.

I am trying to use it to build a real-time quiz app where I want to use DO and web sockets for real-time results. I am trying to implement persistence in hibernate-chat example. But I am running into issues. Could you please help? I am not sure whether my approach is right or wrong or i am missing something.

import { generateHonoObject } from 'hono-do';
import { defineStorage } from 'hono-do/storage';

function uuidv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    const r = (Math.random() * 16) | 0,
      v = c == 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

declare module 'hono-do' {
  interface HonoObjectVars {
    messages: {
      timestamp: string;
      text: string;
    }[];
  }
}

export const Chat = generateHonoObject('/chat', async (app, state, vars) => {
  let { storage } = state;
  const [getValue] = await defineStorage(state.storage, 'value', {});

  // console.log(await state.storage.get('value'), 'aaa');

  vars.messages = [];

  app.get('/messages', async (c) => c.json(await getValue()));

  app.get('/websocket', async (c) => {
    if (c.req.header('Upgrade') === 'websocket') {
      return await handleWebSocketUpgrade();
    }
    return c.text('Not found', 404);
  });

  async function handleWebSocketUpgrade() {
    const [client, server] = Object.values(new WebSocketPair());
    const clientId = uuidv4();
    state.acceptWebSocket(server);
    server.serializeAttachment({ clientId });

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

Chat.webSocketMessage(async (webSocket, msg, state, vars) => {
  const { clientId: senderClientId } = await webSocket.deserializeAttachment();
  const [getValue, setValue] = await defineStorage(state.storage, 'value', {});
  let oldMessages: any = await getValue();
  console.log('msg', msg, vars, state, webSocket);
  oldMessages.push(msg);
  // await state.storage.put('value', oldMessages);
  setValue(oldMessages);
  state.getWebSockets().forEach((ws) => {
    const { clientId } = ws.deserializeAttachment();
    if (clientId === senderClientId) {
      return;
    }
    try {
      vars.messages.push(JSON.parse(msg.toString()));
      ws.send(msg.toString());
    } catch (error) {
      ws.close();
    }
  });
});