Hono の Route Handler 関数の定義時に複数の Middleware の型を扱えるようにするヘルパー関数を実装する

// Route Handler 関数を実装
export const apiRouteHandler = (ctx) => {
  return ctx.json({ message: "宇宙ネコは常にあなたのすぐ近くに居ます🐈" })
}

import { Hono } from "hono";
import { apiRouteHandler } from "./api.ts";

const post = 3000;
const app = new Hono();

// ここで `/api` に apiRouteHandler を設定する
app.get("/api", apiRouteHandler);

console.log(`Server is running on ${port}`);

serve({
  port,
  fetch: app.fetch,
});

import { createFactory } from 'hono/factory'

interface ApiEnv {
  Variables: {
    message: string;
  }
}

// ココで明示的に型を渡す必要がある
const factory = createFactory<ApiEnv>()

// middleware を定義
const middleware = factory.createMiddleware((ctx, next) => {
  ctx.set("message", "宇宙ネコは常にあなたのすぐ近くに居ます🐈")
  return next();
})

// Factory を使って Route Handler を実装する
export const apiRouteHandler = factory.createHandler(
  middleware,
  (ctx) => {
    const message = ctx.get("message"); // ApiEnv を型引数に渡したことによって型が付いている
    return ctx.json({ message })
  }
);

+ import { hogeMiddleware } from "./middlewares.ts"
  import { createFactory } from 'hono/factory'

  interface ApiEnv {
    Variables: {
      message: string;
    }
  }

+ // ココで明示的に型を渡すのが面倒
+ const factory = createFactory<ApiEnv>()

 // middleware を定義
 const middleware = factory.createMiddleware((ctx, next) => {
   ctx.set("message", "宇宙ネコは常にあなたのすぐ近くに居ます🐈")
   return next();
 })

 // Factory を使って Route Handler を実装する
 export const apiRouteHandler = factory.createHandler(
   middleware
+  hogeMiddleware, // ApiEnv と違う型を使っている場合は型エラーが発生し使えない
   (ctx) => {
     const message = ctx.get("message"); // ApiEnv を型引数に渡したことによって型が付いている
     return ctx.json({ message })
   }
 );

import type {
  Env,
  Next,
  Context,
  BlankInput,
  HandlerResponse,
  MiddlewareHandler,
} from "hono";

export type RouteHandler<E extends Env> = (
  c: Context<E, string, BlankInput>, next: Next
) => HandlerResponse<any>;

type GetEnv<
  M extends readonly MiddlewareHandler[],
  R = NonNullable<unknown>,
> = M extends [infer T, ...infer A]
  ? T extends MiddlewareHandler<infer V>
    ? A extends MiddlewareHandler[]
      ? A extends { length: 0 }
        ? { Variables: V["Variables"] & R }
        : GetEnv<A, V["Variables"]>
      : { Variables: V["Variables"] & R }
    : { Variables: R }
  : Env;

export const createRouteHandler = <M extends readonly MiddlewareHandler[]>({
  handler,
  middlewares = [] as unknown as [...M],
}: {
  handler: RouteHandler<GetEnv<[...M]>>;
  middlewares?: [...M];
}): [...M, RouteHandler<GetEnv<[...M]>>] => {
  return [...middlewares, handler];
};