Hono: O Framework Web Ultralight que Está Dominando o Edge Computing com TypeScript

O que é o Hono?

O Hono (em japonês: 炎, que significa "chama") é um framework web ultraleve e de alto desempenho para construir aplicações web modernas. Criado por Yusuke Wada em 2022, o Hono rapidamente conquistou desenvolvedores ao redor do mundo por sua combinação única de performance excepcional e simplicidade de API.

Com apenas 14KB de tamanho (menos que uma imagem JPEG), o Hono é:

• Ultra-rápido: Comparável a frameworks nativos como Bun e Node.js raw em benchmarks de requisições por segundo.
• Multi-runtime: Roda em Cloudflare Workers, Deno, Bun, Node.js, AWS Lambda, Vercel Edge Functions e até no navegador.
• API familiar: Inspirada no Express.js, mas com tipagem rigorosa e padrões mais modernos.
• Middleware rico: Ecossistema extenso de middleware nativo e de terceiros.

Por que Hono e Não Express?

O Express.js foi o padrão para servidores Node.js por mais de uma década, mas suas limitações se tornaram evidentes com o surgimento do edge computing e dos novos runtimes:

Primeiros Passos: Sua Primeira API com Hono

Vamos construir uma API REST simples para gerenciar tarefas. A instalação é trivial:

npm create hono@latest minha-api\ncd minha-api\nnpm install\nnpm run dev

Ou se preferir começar do zero:

mkdir meu-hono-app\ncd meu-hono-app\nnpm init -y\nnpm install hono

import { Hono } from 'hono';\n\nconst app = new Hono();\n\n// Banco em memória\nconst tarefas: { id: number; titulo: string; concluida: boolean }[] = [];\nlet nextId = 1;\n\n// GET /tarefas — listar todas\napp.get('/tarefas', (c) => c.json(tarefas));\n\n// POST /tarefas — criar\napp.post('/tarefas', async (c) => {\n  const { titulo } = await c.req.json();\n  const nova = { id: nextId++, titulo, concluida: false };\n  tarefas.push(nova);\n  return c.json(nova, 201);\n});\n\n// PUT /tarefas/:id — atualizar\napp.put('/tarefas/:id', async (c) => {\n  const id = Number(c.req.param('id'));\n  const { concluida } = await c.req.json();\n  const tarefa = tarefas.find((t) => t.id === id);\n  if (!tarefa) return c.json({ error: 'Tarefa não encontrada' }, 404);\n  tarefa.concluida = concluida;\n  return c.json(tarefa);\n});\n\n// DELETE /tarefas/:id — remover\napp.delete('/tarefas/:id', (c) => {\n  const id = Number(c.req.param('id'));\n  const index = tarefas.findIndex((t) => t.id === id);\n  if (index === -1) return c.json({ error: 'Tarefa não encontrada' }, 404);\n  tarefas.splice(index, 1);\n  return c.json({ message: 'Removida' });\n});\n\nexport default app;

Hono no Edge: Cloudflare Workers

Um dos maiores diferenciais do Hono é sua compatibilidade nativa com ambientes edge. Veja como a mesma API roda em Cloudflare Workers sem nenhuma modificação:

// wrangler.toml\nname = "minha-api-hono"\nmain = "src/index.ts"\ncompatibility_date = "2026-06-01"

O mesmo código TypeScript funciona exatamente igual no Cloudflare Workers, Deno, Bun e Node.js. Sem adaptadores, sem camadas extras, sem surpresas.

Middleware e Ecossistema

O Hono possui um ecossistema de middleware nativo impressionante, que cobre praticamente todas as necessidades de uma aplicação web moderna:

• Bearer Auth: Autenticação via token JWT simplificada — import { bearerAuth } from 'hono/bearer-auth'.
• CORS: Configuração declarativa de cabeçalhos CORS — import { cors } from 'hono/cors'.
• Compress: Compressão gzip/brotli automática — import { compress } from 'hono/compress'.
• Logger: Logging de requisições HTTP estilizado — import { logger } from 'hono/logger'.
• JWT: Validação e decodificação de tokens JWT — import { jwt } from 'hono/jwt'.
• Rate Limiter: Limitação de taxa por IP ou chave — import { rateLimiter } from 'hono/rate-limiter'.
• Serve Static: Servir arquivos estáticos com suporte a cache — import { serveStatic } from 'hono/serve-static'.
• Validação: Integração com Zod para validar requisições — import { zValidator } from 'hono/zod-validator'.

import { Hono } from 'hono';\nimport { logger } from 'hono/logger';\nimport { cors } from 'hono/cors';\nimport { jwt } from 'hono/jwt';\nimport { zValidator } from 'hono/zod-validator';\nimport { z } from 'zod';\n\nconst app = new Hono();\n\n// Middleware global\napp.use('*', logger());\napp.use('/api/*', cors());\napp.use('/api/admin/*', jwt({ secret: process.env.JWT_SECRET! }));\n\n// Validação com Zod\nconst schema = z.object({\n  email: z.string().email(),\n  senha: z.string().min(8),\n});\n\napp.post('/api/login', zValidator('json', schema), async (c) => {\n  const { email } = await c.req.valid('json');\n  return c.json({ message: `Bem-vindo, ${email}!` });\n});\n\nexport default app;

RPC com Hono: Type-Safe Client-Server

Um recurso que diferencia o Hono de absolutamente todos os outros frameworks é o RPC (Remote Procedure Call) — você define a API no servidor e o cliente infere automaticamente os tipos:

// servidor.ts\nimport { Hono } from 'hono';\n\nconst app = new Hono()\n  .get('/api/users', (c) => {\n    return c.json([{ id: 1, nome: 'Alice' }]);\n  })\n  .post('/api/users', async (c) => {\n    const body = await c.req.json();\n    return c.json({ id: 2, ...body }, 201);\n  });\n\nexport type AppType = typeof app;\nexport default app;

// cliente.ts\nimport { hc } from 'hono/client';\nimport type { AppType } from './servidor';\n\nconst client = hc('http://localhost:3000');\n\n// Totalmente tipado — sem precisar gerar SDK!\nconst res = await client.api.users.$get();\nconst data = await res.json();\n// data é automaticamente inferido como { id: number; nome: string }[]

Isso elimina a necessidade de SDKs separados, geradores de cliente OpenAPI ou duplicação de tipos entre front-end e back-end. As mudanças na API do servidor são imediatamente refletidas no cliente — erros de tipo são capturados em tempo de compilação.

Testando uma Aplicação Hono

O Hono foi projetado para ser testável desde o primeiro dia. O objeto de requisição é independente do runtime:

import { describe, test, expect } from 'bun:test';\nimport app from './app';\n\ndescribe('API de Tarefas', () => {\n  test('GET /tarefas retorna lista vazia', async () => {\n    const res = await app.request('/tarefas');\n    expect(res.status).toBe(200);\n    expect(await res.json()).toEqual([]);\n  });\n\n  test('POST /tarefas cria nova tarefa', async () => {\n    const res = await app.request('/tarefas', {\n      method: 'POST',\n      body: JSON.stringify({ titulo: 'Estudar Hono' }),\n      headers: { 'Content-Type': 'application/json' },\n    });\n    expect(res.status).toBe(201);\n    const data = await res.json();\n    expect(data.titulo).toBe('Estudar Hono');\n  });\n});

Sem necessidade de supertest, sem http servers reais — o app.request() invoca o handler diretamente, tornando os testes extremamente rápidos.

Hono na Prática: Casos de Uso Reais

Empresas e projetos open-source estão adotando o Hono em produção para:

• APIs em Edge Functions: Milhares de requisições por segundo com latência mínima em Cloudflare Workers e Vercel Edge.
• Backends para aplicações mobile: APIs REST leves com tipagem compartilhada entre servidor e cliente mobile.
• Microserviços serverless: Funções AWS Lambda usando Hono para roteamento e middleware com bundle mínimo.
• Ferramentas de desenvolvimento: Servidores locais embutidos em CLIs (como o wrangler dev usa Hono internamente para preview).
• Proxies e gateways: Roteamento inteligente em edge computing com validação de requisições em tempo real.

O Futuro do Hono

O Hono não é apenas mais um framework web — ele representa uma mudança de paradigma na forma como construímos e distribuímos aplicações web. Enquanto frameworks como Express e Fastify foram projetados para uma era de servidores dedicados, o Hono foi construído para a era do edge computing: leve o suficiente para rodar em ambientes com restrição de tamanho, rápido o suficiente para suportar milhões de requisições, e flexível o suficiente para funcionar em qualquer runtime JavaScript moderno.

Com a versão 5.x já consolidada e a comunidade crescendo exponencialmente, o Hono está rapidamente se tornando o framework padrão para novas aplicações web TypeScript — especialmente para quem busca performance máxima sem abrir mão da produtividade do desenvolvedor.