Best way to manage and mount routes in a DRY way

[jamiehaywood]

I'm looking at creating a routes.ts file with all my routes and the middlewares associated with each route:

// routes.ts
import { MiddlewareHandler, Hono, Context } from "hono";
import { METHODS } from "hono/dist/types/router";

type Methods = (typeof METHODS)[number];

interface Routes {
  path: string;
  method: Pick<Hono, Methods> extends string ? Pick<Hono, Methods> : Methods;
  middlewares: MiddlewareHandler[];
}

const routes: Routes[] = [
  {
    path: "/bar",
    method: "get",
    middlewares: [async (c: Context) => c.json({ bar: "bar" })],
  },
  {
    path: "/foo",
    method: "get" as const,
    middlewares: [async (c: Context) => c.json({ foo: "foo" })],
  },
];

and consuming in my index.ts

// index.ts
const app = new Hono();
routes.map((route) => app[route.method](route.path, ...route.middlewares));
...

Do you think this is a good way to cleanly organise and mount the middlewares?

[jamiehaywood]

As a separate point - are there any plans to consolidate the types into a single exported file, so we can avoid importing from hono/dist/types/... ?

[yusukebe]

METHODS is for internal use only.

[jamiehaywood]

I disagree that METHODS should be redefined by the consumer. What's the reason behind keeping it internal only?

[yusukebe]

This is because we do not expect users to use METHOD directly. Most of all, users will use app.get() and other app.METHOD functions. Also, we don't want to add more exporting types and constants to reduce maintenance costs.

[yusukebe]

This code is best:

import { MiddlewareHandler, Handler, Hono } from 'hono'
import { createFactory } from 'hono/factory'

type Methods = ['get', 'post', 'put', 'delete', 'options', 'patch'][number]

interface Routes {
  path: string
  method: Methods
  handlers: (Handler | MiddlewareHandler)[]
}

const factory = createFactory()

const routes: Routes[] = [
  {
    path: '/bar',
    method: 'get',
    handlers: factory.createHandlers((c) => c.json({ bar: 'bar' }))
  },
  {
    path: '/foo',
    method: 'get' as const,
    handlers: factory.createHandlers((c) => c.json({ foo: 'foo' }))
  }
]

const app = new Hono()
routes.map((route) => app.on(route.method, route.path, ...route.handlers))

export default app

[jamiehaywood]

thanks for your reply.
I have a couple of follow up questions around the code you posted being best:

1. createFactory and createMiddleware looks to be primarily types helper in the source. Is the primary function of this to pass the Context type in a reusable manner into handlers defined in createHandlers?
2. Is there any difference between app.on(route.method) and app[route.method], or is it another function to improve developer ergonomics?

[yusukebe]

1. Yes
2. No difference.

[jamiehaywood]

great thanks for your help!