Need help with hono types.

[dimik]

Hi @yusukebe , first of all, thank you for such an amazing router. We're using it for our BFF (backend for frontend) application.

I'm trying to migrate our bff-client app to your hono/client RPC to reduce types declaration boilerplate and it looks very promising.
However i have a small complication with our routes composing helper, that aggregates routes in more declarative way, that now looks like this:

import { Env, Hono } from 'hono';

export function composeHonoRoutes<E extends Env = Env>(path: string, routes: Hono<E>[], app = new Hono<E>()): Hono<E> {
  return routes.reduce((acc, route) => {
    acc.route(path, route);
    return acc;
  }, app);
};

But looks like it's not the proper approach of routes aggregation for hono/client as i'm getting "unknown" when trying to do like so:

const app = composeHonoRoutes<HonoEnv>('/api/account/v1', routes, new Hono<HonoEnv>());
export default app;
export type AppType = typeof app;
const client = hc<AppType>('/');  // const client: unknown

In my understanding I need to change this helper like this to order to make it work, please notice that i return Hono.route, instead of Hono instance

export function composeHonoRoutes<E extends Env = Env>(path: string, routes: Hono<E>[], app = new Hono<E>()): Hono<E> {
  return routes.reduce((acc, route) => {
    return acc.route(path, route);
  }, app);
};

But i have a complication to properly type it. Could you please help me with that?

So what i want to archive is instead of this one:

const foo = new Hono<HonoEnv>().get('/foo', c => c.jsonT({ foo: 'foo' }))
const bar = new Hono<HonoEnv>().get('/bar', c => c.jsonT({ bar: 'bar' }))
const baz = new Hono<HonoEnv>().get('/baz', c => c.jsonT({ baz: 'baz' }))

const app = new Hono<HonoEnv>().basePath('/api/account')
  .route('/v1', foo)
  .route('/v1', bar)
  .route('/v1', baz)

to do like this (please notice that I wish to use Hono.basePath as well)

const routes = [ foo, bar, baz ]; // thit list is imported from nested route folders

const app = composeHonoRoutes('/v1', routes, new Hono<HonoEnv>().basePath('/api/account'));

thank you!

[yusukebe]

Hi @dimik,

Thank you for using Hono!

I understand that you're looking for a way to simplify your code. However, with your approach, inferring the type for a client becomes very difficult. The type system is complicated, so it's not easy to explain. However, certain features, like Schemas or BasePath inside of Hono, could be missed with your approach. For example, we could create the application for specific Types, but it wouldn't be enough.

export function composeHonoRoutes<H1 extends Hono, H2 extends Hono>(
  routes: [H1, H2],
  app = new Hono()
): H1 | H2 {
  return routes.reduce((acc, route) => {
    acc.route('/', route)
    return acc
  }, app) as never
}

const foo = new Hono().get('/foo', (c) => c.jsonT({ foo: 'foo' }))
const bar = new Hono().get('/bar', (c) => c.jsonT({ bar: 'bar' }))

const app = composeHonoRoutes([foo, bar], new Hono())

So, I don't recommend creating composeHonoRoutes().