Feature Request: Official minimal BaseHandler class for clean, decorator-free route handlers

[see7788]

What is the feature you are proposing?

Hi Hono team!

I love that Hono is fast, tiny, and avoids unnecessary abstractions. But when building apps, I keep coming back to a simple need: a built-in way to write plain class-based handlers without decorators, middleware chains, or reflection.

The core idea is this: a service is just a few classes (for GET, POST, WS, etc.), each with:

Special members like headers, cookie, query, body
Public methods like json(), jsx(), redirect(), validate(), jwt.sign()
No @get(), no DI containers, no pipeline — just explicit, testable, readable code.

Example:

ts
编辑
class LoginHandler extends BaseHandler {
async handle() {
const { email, password } = await this.body;
if (!this.cookie.includes('auth=')) {
return this.json({ error: 'Unauthorized' }, 401);
}
const user = await db.find(email);
return this.json({ id: user.id, name: user.name });
}
}

app.post('/login', (c) => new LoginHandler(c).handle());
This pattern is:

Easy to test (just new LoginHandler(mockCtx))
Fully tree-shakable
Zero runtime overhead
Aligns with Hono’s “you don’t pay for what you don’t use” philosophy
Proposal:

Export a lightweight BaseHandler class from hono (or hono/handler)
Pre-bind common properties (this.body, this.cookie, etc.) and helpers (this.json())
Document this as an official “minimal class-based” style
It wouldn’t change anything for existing users — just give simplicity-minded developers a blessed path.

Would you consider this? I’d be happy to help draft a PR.

Thanks for your amazing work! 🙏

[ysknsid25]

How about like this?

Sample

import { serve } from "@hono/node-server";
import { Hono } from "hono";
import type { Context } from "hono";
import type { ContentfulStatusCode } from "hono/utils/http-status";

// add to Hono Start
abstract class BaseHandler {
    protected c: Context;

    constructor(c: Context) {
        this.c = c;
    }

    // for example start. debatable. It might be more flexible to just have `c` call it
    protected get body() {
        return this.c.req.json();
    }

    protected get query() {
        return this.c.req.query();
    }

    protected json(data: any, status: ContentfulStatusCode = 200) {
        return this.c.json(data, status);
    }

    protected get cookie() {
        return this.c.req.raw.headers.get("Cookie") || "";
    }
    // for example end

    // this is the main handler method to be implemented by subclasses
    abstract handle(): Promise<Response> | Response;
}

const classHandler = (HandlerClass: new (c: Context) => BaseHandler) => {
    return (c: Context) => {
        const handler = new HandlerClass(c);
        return handler.handle();
    };
};
// add to Hono End

// Client App Start
class LoginHandler extends BaseHandler {
    async handle() {
        const { email, password } = await this.body;
        if (!this.cookie.includes("auth=")) {
            return this.json({ error: "Unauthorized" }, 401);
        }
        const find = async (email: string, password: string) => {
            return {
                id: 1,
                name: "John Doe",
                email: email,
                password: password,
            };
        };
        const user = await find(email, password);
        return this.json({ id: user.id, name: user.name });
    }
}

const app = new Hono();

app.post("/login", classHandler(LoginHandler));

serve(
    {
        fetch: app.fetch,
        port: 8080,
    },
    (info) => {
        console.log(`Server is running on http://localhost:${info.port}`);
    }
);

// Client App End

// mockTest Example
const mockContext: Context = {} as Context;
const loginHandler = new LoginHandler(mockContext).handle();

Test

curl -X POST http://localhost:8080/login -H 'Content-Type: application/json' -H 'Cookie: auth=token' -d '{"email": "test@example.com", "password": "yourpass"}'

Result

{"id":1,"name":"John Doe"}

But is it same this?

const loginHandler = (c: Context) => { somethingHelper(c) }
const somethingHelper = (c: Context) => {...}

// no pass around
class LoginHandler extends BaseHandler {
    async handle() {}
    private async somethingHelper(){ /* callable by `this.c` */ }
}

Two advantage may be...

• We don't have to pass around c for helper functions for handlers.
• We can encapsulate the helper in a class.

[see7788]

Absolutely! Here's a single-paragraph version that preserves all the clarity and structure of your original intent—just without line breaks—so it reads smoothly while remaining precise and easy to understand:

Hi Hono team! I love Hono’s speed, minimalism, and avoidance of unnecessary abstractions, but I’d like to propose an official, lightweight way to write class-based handlers that are both type-safe and protocol-aware. Currently, Hono uses a single Context type that tries to support all protocols (HTTP, WebSocket, etc.), which leads to unclear capability boundaries—for example, HTTP handlers have access to cookies and request bodies, while WebSocket handlers do not, yet the types don’t enforce this distinction, making it easy to accidentally misuse methods like c.req.cookie() in a WebSocket route. My suggestion is to provide official base classes such as HttpHandler (which exposes body, cookie, json(), etc.) and WebSocketHandler (which provides send(), onMessage(), but no HTTP-specific properties), each strictly reflecting the capabilities of its protocol. These would be paired with simple factory helpers like httpHandler(MyClass) or wsHandler(MyClass) to integrate seamlessly with Hono’s routing system. This approach keeps zero runtime overhead, enables fully encapsulated and testable class logic without decorators or dependency injection, and aligns perfectly with Hono’s “you don’t pay for what you don’t use” philosophy—while making the API more explicit, safer, and easier to reason about. Would you consider adopting this as a first-class pattern?

// hono/http-handler.ts
abstract class HttpHandler {
constructor(protected c: HttpContext) {}
get body() { return this.c.req.json() }
get cookie() { return this.c.req.header('Cookie') }
json(data: any, status = 200) { return this.c.json(data, status) }
abstract handle(): Response | Promise
}

// hono/ws-handler.ts
abstract class WebSocketHandler {
constructor(protected ws: WebSocket, protected c: WsContext) {}
send(data: string) { this.ws.send(data) }
close() { this.ws.close() }
// ❌ no body, no cookie, no json()
abstract onMessage(message: string): void
}