Hono.js en 2026: El Backend Ultraligero que Corre en Edge, Bun y Node

// Hono en 2026 — mismo código en Cloudflare, Bun, Deno y Node
import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hola desde el edge! ⚡'))

app.get('/api/users/:id', async (c) => {
  const id = c.req.param('id') // tipado automático
  const user = await c.env.DB.prepare('SELECT * FROM users WHERE id = ?').bind(id).first()
  return c.json(user)
})

// Un solo handler, 4 runtimes:
// - Cloudflare Workers: export default app
// - Bun: Bun.serve({ fetch: app.fetch })
// - Deno: Deno.serve(app.fetch)
// - Node: serve(app) con @hono/node-server
export default app

// server.ts — API con validación Zod + RPC (2026)
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono()
  .get('/api/posts', async (c) => {
    const posts = await db.posts.findMany()
    return c.json({ posts })
  })
  .post('/api/posts', zValidator('json', z.object({
    title: z.string().min(3),
    content: z.string().min(10)
  })), async (c) => {
    const { title, content } = c.req.valid('json') // 100% tipado
    const post = await db.posts.create({ data: { title, content } })
    return c.json(post, 201)
  })

export type AppType = typeof app // ← esto es todo lo que necesitas

// client.ts — cliente type-safe sin generar nada
import { hc } from 'hono/client'
import type { AppType } from './server'

const client = hc<AppType>('http://localhost:3000')

// Autocomplete total, error si el body no cumple Zod
const res = await client.api.posts.$post({
  json: { title: 'Mi post', content: 'Contenido largo...' }
})
if (res.ok) {
  const post = await res.json() // tipo inferido: { id: string, title: string, ... }
}

// ❌ Error en compile time si te equivocas
await client.api.posts.$post({ json: { title: 'ab' } }) // title min 3 → TS error

import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { logger } from 'hono/logger'
import { bearerAuth } from 'hono/bearer-auth'
import { cache } from 'hono/cache'

const app = new Hono()

// Stack prod 2026 — 5 líneas
app.use('*', logger())
app.use('/api/*', cors({ origin: ['https://myapp.com'], credentials: true }))
app.use('/api/admin/*', bearerAuth({ token: process.env.ADMIN_TOKEN! }))
app.use('/api/posts/*', cache({ cacheName: 'posts', cacheControl: 'max-age=60' }))

// Auth con Better Auth / Clerk / Lucia en 2026
import { auth } from './auth' // Better Auth en Hono es 1 línea

app.use('*', async (c, next) => {
  const session = await auth.api.getSession({ headers: c.req.header() })
  c.set('user', session?.user)
  await next()
})

app.get('/api/me', (c) => {
  const user = c.get('user')
  if (!user) return c.json({ error: 'Unauthorized' }, 401)
  return c.json(user)
})

// Migración Express → Hono en 10 minutos (2026)
// Express:
app.get('/api/users/:id', (req, res) => {
  res.json({ id: req.params.id })
})
// Hono:
app.get('/api/users/:id', (c) => c.json({ id: c.req.param('id') }))
// Diferencias: c.req.param vs req.params, c.json vs res.json, return c.* en Hono

// wrangler.toml — Cloudflare Workers (2026)
name = "my-hono-api"
main = "src/index.ts"
compatibility_date = "2026-06-01"

[vars]
NODE_ENV = "production"

[[d1_databases]]
binding = "DB"
database_name = "my-db"
database_id = "xxxx"

// src/index.ts — mismo app en 3 targets
import { Hono } from 'hono'
const app = new Hono<{ Bindings: { DB: D1Database } }>()

app.get('/api/health', (c) => c.json({ ok: true, region: c.env.CF_REGION }))

// Cloudflare Workers
export default app
// Bun (local dev ultra-rápido): Bun.serve({ fetch: app.fetch, port: 3000 })
// Node (fallback): import { serve } from '@hono/node-server'; serve({ fetch: app.fetch, port: 3000 })

# Dev con Bun (HMR 40ms) + deploy a Workers (global)
bun install hono
bun run dev          # Bun -- 40ms HMR, 0 config
bunx wrangler deploy # Cloudflare -- 18ms global, 0 cold start

# Vercel Edge (mismo código)
# vercel.json: { "functions": { "api/index.ts": { "runtime": "edge" } } }

# Arquitectura 2026 recomendada
frontend: TanStack Start o Next.js 16 (Vercel / Cloudflare Pages)
api: Hono 4.7 (Cloudflare Workers + D1/KV/R2)
db: Cloudflare D1 (SQLite edge) + Drizzle ORM o Neon Postgres
auth: Better Auth (soporta Hono nativo) o Clerk
validación: Zod + @hono/zod-validator
docs: hono-openapi → Swagger UI automático
monitor: Sentry + Cloudflare Analytics

// src/db/schema.ts — Drizzle ORM (2026)
import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
export const posts = sqliteTable('posts', {
  id: text('id').primaryKey(),
  title: text('title').notNull(),
  content: text('content').notNull(),
  createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
})

// src/routes/posts.ts — CRUD completo con Hono + Drizzle + Zod
import { Hono } from 'hono'
import { zValidator } from '@hono/zod-validator'
import { drizzle } from 'drizzle-orm/d1'
import { posts } from '../db/schema'
import { z } from 'zod'

const postsApp = new Hono<{ Bindings: { DB: D1Database } }>()

postsApp.get('/', async (c) => {
  const db = drizzle(c.env.DB)
  const all = await db.select().from(posts).all()
  return c.json({ posts: all })
})

postsApp.post('/', zValidator('json', z.object({
  title: z.string().min(3).max(100),
  content: z.string().min(10)
})), async (c) => {
  const { title, content } = c.req.valid('json')
  const db = drizzle(c.env.DB)
  const id = crypto.randomUUID()
  await db.insert(posts).values({ id, title, content, createdAt: new Date() })
  return c.json({ id, title, content }, 201)
})

export default postsApp

// src/index.ts — monta sub-routers
import { Hono } from 'hono'
import postsApp from './routes/posts'

const app = new Hono()
app.route('/api/posts', postsApp)
app.get('/', (c) => c.text('API Hono 2026 🔥 18ms global'))
export default app