Hono

Hono is a community skill for building web applications with the Hono framework, covering route definition, middleware composition, request validation, multi-runtime deployment, and API documentation generation for lightweight edge and server applications.

What Is This?

Overview

Hono provides patterns for building fast web applications using the Hono framework which runs on any JavaScript runtime. It covers route definition that creates typed HTTP endpoints with path parameters, query handling, and response formatting, middleware composition that chains request processing functions for authentication, logging, CORS, and rate limiting, request validation that validates incoming request bodies and parameters using Zod schemas with automatic error responses, multi-runtime deployment that configures applications for Cloudflare Workers, Deno, Bun, and Node.js with runtime-specific adapters, and API documentation generation that produces OpenAPI specifications from route definitions. The skill enables developers to build performant APIs that deploy across multiple JavaScript runtimes.

Who Should Use This

This skill serves backend developers building APIs for edge and serverless platforms, full-stack engineers seeking a lightweight alternative to Express, and teams deploying to multiple JavaScript runtimes.

Why Use It?

Problems It Solves

Express and similar frameworks carry legacy patterns that add overhead for simple API services. Applications locked to a single runtime cannot easily migrate between Node.js, Deno, and edge platforms. Request validation added separately from route definitions creates maintenance gaps where validation drifts from actual endpoint behavior. API documentation written manually becomes outdated as routes change.

Core Highlights

Router defines typed endpoints with automatic path parameter extraction. Middleware chain composes request processors with next function control flow. Validator integrates Zod schemas directly in route definitions for request checking. Runtime adapter configures the same application code for different deployment targets.

How to Use It?

Basic Usage

// Hono API setup
import { Hono } from 'hono'
import { cors }
  from 'hono/cors'
import { logger }
  from 'hono/logger'

const app = new Hono()

app.use('*', logger())
app.use('/api/*', cors())

app.get('/', (c) =>
  c.json({
    message: 'Hello'
  }))

app.get(
  '/api/users/:id',
  (c) => {
    const id =
      c.req.param('id')
    return c.json({
      id,
      name: 'User'
    })
  })

app.post(
  '/api/users',
  async (c) => {
    const body =
      await c.req.json()
    return c.json(
      { created: true },
      201)
  })

export default app

Real-World Examples

// Validated API with Zod
import { Hono } from 'hono'
import { zValidator }
  from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono()

const createUserSchema =
  z.object({
    name: z.string()
      .min(1).max(100),
    email: z.string()
      .email(),
    role: z.enum([
      'admin', 'user'])
  })

app.post(
  '/api/users',
  zValidator(
    'json',
    createUserSchema),
  async (c) => {
    const data =
      c.req.valid('json')
    const user = {
      id: crypto
        .randomUUID(),
      ...data
    }
    return c.json(
      user, 201)
  })

app.get(
  '/api/users',
  zValidator(
    'query',
    z.object({
      page: z.string()
        .optional()
        .transform(
          Number),
      limit: z.string()
        .optional()
        .transform(
          Number)
    })),
  (c) => {
    const { page, limit }
      = c.req.valid(
        'query')
    return c.json({
      page: page || 1,
      limit: limit || 20,
      users: []
    })
  })

export default app

Advanced Tips

Use Hono RPC client to generate type-safe API clients from route definitions that share types between server and client without code generation tools. Group related routes with app.route for modular application structure. Use the factory pattern with createMiddleware for reusable middleware with typed context variables.

When to Use It?

Use Cases

Build a REST API for Cloudflare Workers with request validation and typed responses. Create a lightweight backend service that runs on Bun or Deno without framework lock-in. Generate OpenAPI documentation from route definitions for API consumer reference.

Related Topics

Web frameworks, edge computing, Cloudflare Workers, REST APIs, middleware, request validation, and multi-runtime JavaScript.

Important Notes

Requirements

JavaScript runtime such as Node.js, Deno, Bun, or Cloudflare Workers. Hono package installed via npm, jsr, or runtime package manager. Zod library for schema-based request validation.

Usage Recommendations

Do: use the zValidator middleware for request validation to maintain type safety from request to handler. Structure applications with route groups for maintainable code organization. Test routes using the built-in app.request method without starting a server.

Don't: add heavy middleware to all routes when only specific paths need them since Hono runs on resource-constrained edge environments. Use Node.js specific APIs without checking runtime compatibility when targeting multiple platforms. Ignore the typed context system which provides compile-time safety for middleware data.

Limitations

Hono ecosystem is smaller than Express with fewer third-party middleware packages available. Some advanced Node.js features like streaming and WebSocket handling vary across runtime targets. The lightweight design means features like built-in template rendering require additional packages.