Hono: det ultrahurtige webframework bygget på Web Standards

I årevis betød valget af et JavaScript-webframework at acceptere et kompromis: Express var universel, men langsom og bundet til Node, Fastify hurtig, men kun Node, Next.js fuldfeatured, men tung. Da edge-runtimes — Cloudflare Workers, Deno Deploy, Bun, Vercel Edge — kom, viste de frameworks deres grænser.

Hono (japansk for "flamme" 🔥) er det moderne svar. Et framework under 14KB, fuldt bygget på Web Standards (Request, Response, fetch), der kører overalt, hvor der findes en JavaScript-runtime. Den samme kode deployes til Cloudflare Workers, Bun, Deno, Node.js, Vercel, Netlify og AWS Lambda — uden ændringer.

Hvorfor Hono

1. Ydeevne. RegExpRouter kompilerer alle route-mønstre til ét regex. Benchmarks overstiger 400.000 ops/s.
2. Portabilitet. Web Standards betyder nul Node-afhængigheder.
3. TypeScript-first DX. Path-parametre udledes som literal-typer, end-to-end type-safe RPC-klient.

Kom i gang

npm create hono@latest my-api
cd my-api
npm install
npm run dev

// src/index.ts
import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hello Hono!'))

export default app

På Cloudflare Workers er det nok. På Bun: Bun.serve({ fetch: app.fetch, port: 3000 }). På Node: serve({ fetch: app.fetch }) fra @hono/node-server.

Routing

import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Home'))
app.get('/posts/:id', (c) => {
  const id = c.req.param('id')
  return c.json({ id })
})
app.get('/posts/:id/comments/:commentId', (c) => {
  const { id, commentId } = c.req.param()
  return c.json({ id, commentId })
})
app.get('/files/*', (c) => c.text('Wildcard'))
app.post('/posts', async (c) => {
  const body = await c.req.json()
  return c.json({ created: body }, 201)
})

Gruppering af routes

// routes/posts.ts
import { Hono } from 'hono'

const posts = new Hono()
posts.get('/', (c) => c.json({ posts: [] }))
posts.get('/:id', (c) => c.json({ id: c.req.param('id') }))
export default posts

// src/index.ts
import { Hono } from 'hono'
import posts from './routes/posts'

const app = new Hono()
app.route('/posts', posts)

Context-objektet

app.post('/echo', async (c) => {
  const userAgent = c.req.header('User-Agent')
  const page = c.req.query('page')
  const body = await c.req.json()
  const env = c.env

  c.set('requestId', crypto.randomUUID())
  const id = c.get('requestId')

  c.header('X-Request-Id', id)
  c.status(200)
  return c.json({ userAgent, page, body, id })
})

Middleware: løgmodellen

import { Hono } from 'hono'
import { logger } from 'hono/logger'
import { cors } from 'hono/cors'
import { secureHeaders } from 'hono/secure-headers'

const app = new Hono()

app.use('*', logger())
app.use('*', secureHeaders())
app.use('/api/*', cors({ origin: 'https://spinny.dev' }))

app.use('*', async (c, next) => {
  const start = performance.now()
  await next()
  c.header('X-Response-Time', `${performance.now() - start}ms`)
})

Indbygget middleware

Middleware	Formål
logger	Strukturerede logs af metode, sti, status, varighed
cors	CORS konfigurerbar pr. origin, metoder, headers
csrf	Origin-baseret CSRF-beskyttelse
secureHeaders	Sætter CSP, HSTS, X-Frame-Options
bearerAuth / basicAuth	Klar Bearer/Basic-auth
jwt	Verificer/signer JWT med jose
etag	Genererer ETag og håndterer 304
cache	Cache via Web Cache API
compress	gzip/deflate på respons
bodyLimit	Afviser bodies over tærskel
timing	Server-Timing-header til profilering

Type-safe brugerdefineret middleware

import { createMiddleware } from 'hono/factory'

type AuthVars = { userId: string; role: 'user' | 'admin' }

export const requireAuth = createMiddleware<{ Variables: AuthVars }>(
  async (c, next) => {
    const token = c.req.header('Authorization')?.replace('Bearer ', '')
    if (!token) return c.json({ error: 'Unauthorized' }, 401)

    const payload = await verifyJwt(token)
    c.set('userId', payload.sub)
    c.set('role', payload.role)
    await next()
  }
)

app.get('/me', requireAuth, (c) => {
  const userId = c.var.userId
  return c.json({ userId })
})

Validering med Zod

import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const createPost = z.object({
  title: z.string().min(1).max(200),
  body: z.string().min(1),
  tags: z.array(z.string()).default([]),
})

app.post(
  '/posts',
  zValidator('json', createPost),
  (c) => {
    const data = c.req.valid('json')
    return c.json({ ok: true, post: data }, 201)
  }
)

RPC: end-to-end type-safe klient

// server.ts
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono()
  .get('/posts/:id', (c) =>
    c.json({ id: c.req.param('id'), title: 'Hello' })
  )
  .post(
    '/posts',
    zValidator('json', z.object({ title: z.string(), body: z.string() })),
    (c) => c.json({ ok: true }, 201)
  )

export type AppType = typeof app
export default app

// client.ts
import { hc } from 'hono/client'
import type { AppType } from './server'

const client = hc<AppType>('https://api.spinny.dev')

const res = await client.posts[':id'].$get({ param: { id: '42' } })
if (res.ok) {
  const data = await res.json()
  console.log(data.title)
}

const created = await client.posts.$post({
  json: { title: 'Hej', body: 'Hono er en flamme' },
})

Statuskodediskrimination

.get('/posts/:id', (c) => {
  const post = findPost(c.req.param('id'))
  if (!post) return c.json({ error: 'not found' }, 404)
  return c.json({ post }, 200)
})

const res = await client.posts[':id'].$get({ param: { id } })
if (res.status === 404) {
  const { error } = await res.json()
}
if (res.status === 200) {
  const { post } = await res.json()
}

Routere og ydeevne

Router	Styrker	Hvornår bruges
RegExpRouter	Maksimal hastighed, kompileret regex	Standard for de fleste APIs
TrieRouter	Understøtter alle mønstre	Komplekse mønstre RegExp ikke håndterer
SmartRouter	Vælger automatisk det bedste	Anbefalet standard
LinearRouter	Ultrahurtig registrering	One-shot workers, kritisk cold start
PatternRouter	Minimalt bundle (<15KB)	Ekstreme størrelsesbegrænsninger

import { Hono } from 'hono'
import { LinearRouter } from 'hono/router/linear-router'

const app = new Hono({ router: new LinearRouter() })

Multi-runtime deploy

Cloudflare Workers

import { Hono } from 'hono'

type Bindings = { MY_KV: KVNamespace; DB: D1Database }
const app = new Hono<{ Bindings: Bindings }>()

app.get('/cache/:key', async (c) => {
  const value = await c.env.MY_KV.get(c.req.param('key'))
  return c.json({ value })
})

export default app

Deploy: npx wrangler deploy.

Bun

import { Hono } from 'hono'
const app = new Hono()
app.get('/', (c) => c.text('Bun + Hono'))

Bun.serve({ fetch: app.fetch, port: 3000 })

Node.js

import { serve } from '@hono/node-server'
import { Hono } from 'hono'

const app = new Hono()
app.get('/', (c) => c.text('Node + Hono'))

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

Deno

import { Hono } from 'jsr:@hono/hono'
const app = new Hono()
app.get('/', (c) => c.text('Deno + Hono'))
Deno.serve(app.fetch)

Vercel

// api/[[...route]].ts
import { Hono } from 'hono'
import { handle } from 'hono/vercel'

const app = new Hono().basePath('/api')
app.get('/hello', (c) => c.json({ msg: 'Hello from Vercel' }))

export const GET = handle(app)
export const POST = handle(app)

Praktisk eksempel: REST API med auth og DB

import { Hono } from 'hono'
import { jwt } from 'hono/jwt'
import { logger } from 'hono/logger'
import { cors } from 'hono/cors'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

type Bindings = { DB: D1Database; JWT_SECRET: string }
type Variables = { jwtPayload: { sub: string } }

const app = new Hono<{ Bindings: Bindings; Variables: Variables }>()

app.use('*', logger())
app.use('/api/*', cors({ origin: 'https://spinny.dev', credentials: true }))

const auth = (c: any, next: any) =>
  jwt({ secret: c.env.JWT_SECRET })(c, next)

const api = app.basePath('/api')

api.get('/posts', async (c) => {
  const { results } = await c.env.DB
    .prepare('SELECT id, title, created_at FROM posts ORDER BY created_at DESC LIMIT 50')
    .all()
  return c.json({ posts: results })
})

api.post(
  '/posts',
  auth,
  zValidator('json', z.object({
    title: z.string().min(1).max(200),
    body: z.string().min(1),
  })),
  async (c) => {
    const { title, body } = c.req.valid('json')
    const userId = c.var.jwtPayload.sub
    const result = await c.env.DB
      .prepare('INSERT INTO posts (title, body, author_id) VALUES (?, ?, ?) RETURNING id')
      .bind(title, body, userId)
      .first<{ id: number }>()
    return c.json({ id: result?.id }, 201)
  }
)

api.onError((err, c) => {
  console.error(err)
  return c.json({ error: 'Internal error' }, 500)
})

export type AppType = typeof api
export default app

Test

import { describe, it, expect } from 'vitest'
import app from '../src/index'

describe('GET /api/posts', () => {
  it('returnerer listen af posts', async () => {
    const res = await app.request('/api/posts')
    expect(res.status).toBe(200)
    const body = await res.json()
    expect(body.posts).toBeInstanceOf(Array)
  })
})

Bedste praksis

1. Kæd route-definitioner

const app = new Hono()
  .get('/posts', handler1)
  .post('/posts', handler2)
  .get('/posts/:id', handler3)

2. Eksportér typen, ikke implementeringen

Klienten skal importere AppType.

3. Én router pr. domæne

Sub-app til posts, users, webhooks.

4. Validering ved kanten, altid

Hvert eksternt input skal igennem zValidator.

5. Læn dig op ad bindings, ikke globale klienter

På Cloudflare tilgås KV/D1/R2 via c.env.

6. Mål før du optimerer routeren

Standard-SmartRouter passer i 95% af tilfældene.

Konklusion

Hono er i 2026 blevet de facto-standarden til at bygge edge-klare APIs i TypeScript.

Kom-i-gang-tjekliste:

• npm create hono@latest og vælg din runtime-skabelon
• Definér routes med kædning (.get(...).post(...))
• Tilføj logger, cors, secureHeaders som global middleware
• Validér hvert input med @hono/zod-validator
• Eksportér AppType og forbrug API'et med type-safe hc-klient
• Skriv tests med app.request() — ingen HTTP-server nødvendig
• Deploy med wrangler deploy (CF), vercel deploy eller din runtimes bundler