Primeros Pasos con HonoJS para APIs Web Ligeras

Construir APIs web modernas no debería requerir frameworks pesados o configuraciones complejas. Si buscas una alternativa rápida y ligera a Express o Koa que funcione en múltiples entornos de ejecución de JavaScript, HonoJS podría ser exactamente lo que necesitas.

Qué Hace Diferente a HonoJS

HonoJS es un framework web pequeño y ultrarrápido construido sobre Estándares Web. A diferencia de los frameworks tradicionales de Node.js, se ejecuta en cualquier entorno de ejecución de JavaScript—Node.js, Bun, Deno, Cloudflare Workers, AWS Lambda y más. Esta portabilidad proviene de su fundamento en APIs Web estándar como Request, Response y Fetch.

import { Hono } from 'hono'
const app = new Hono()

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

export default app

Esa es una aplicación completa de HonoJS. Sin código repetitivo, sin configuración compleja—solo JavaScript moderno y limpio.

Configurando Tu Primera API con HonoJS

Construyamos una API REST simple para ver HonoJS en acción. Primero, crea un nuevo proyecto:

npm create hono@latest my-api

Elige tu entorno de ejecución preferido (Node.js, Bun o Cloudflare Workers). Para este ejemplo, usaremos Node.js:

cd my-api
npm install
npm run dev

Tu servidor ahora está ejecutándose en http://localhost:3000.

Construyendo Rutas REST con HonoJS

HonoJS usa una sintaxis de enrutamiento familiar que se siente natural si has usado Express:

import { Hono } from 'hono'
const app = new Hono()

// Endpoint GET
app.get('/api/users', (c) => {
  const users = [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' }
  ]
  return c.json(users)
})

// Endpoint POST con parsing de JSON
app.post('/api/users', async (c) => {
  const body = await c.req.json()
  // En producción, guardar en base de datos
  return c.json({ message: 'User created', data: body }, 201)
})

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

export default app

El objeto Context (c) proporciona todo lo que necesitas: datos de solicitud, helpers de respuesta y utilidades para headers, cookies y más.

Middleware para APIs Listas para Producción

HonoJS incluye middleware esencial listo para usar. Aquí te mostramos cómo agregar CORS, logging y compresión:

import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { logger } from 'hono/logger'
import { compress } from 'hono/compress'

const app = new Hono()

// Aplicar middleware
app.use('*', logger())
app.use('*', cors())
app.use('*', compress())

// Tus rutas aquí
app.get('/api/health', (c) => c.json({ status: 'ok' }))

export default app

Crear middleware personalizado es sencillo:

// Middleware de autenticación simple
const authMiddleware = async (c, next) => {
  const token = c.req.header('Authorization')
  if (!token || token !== 'Bearer secret-token') {
    return c.json({ error: 'Unauthorized' }, 401)
  }
  await next()
}

// Aplicar a rutas específicas
app.use('/api/protected/*', authMiddleware)
app.get('/api/protected/data', (c) => {
  return c.json({ secret: 'This is protected data' })
})

Portabilidad de Entorno de Ejecución: Despliega en Cualquier Lugar

Una de las mayores ventajas de HonoJS es su flexibilidad de entorno de ejecución. El mismo código funciona en diferentes plataformas con cambios mínimos:

Para Cloudflare Workers:

export default app

Para Node.js:

import { serve } from '@hono/node-server'
serve({ fetch: app.fetch, port: 3000 })

Para Bun:

export default { port: 3000, fetch: app.fetch }

Esto significa que puedes comenzar el desarrollo localmente y desplegar en ubicaciones edge sin reescribir tu API.

Extendiendo con Integración de Base de Datos

Aquí tienes un ejemplo rápido usando Drizzle ORM con HonoJS:

import { Hono } from 'hono'
import { drizzle } from 'drizzle-orm/better-sqlite3'
import Database from 'better-sqlite3'
import { postsTable } from './schema'

const sqlite = new Database('app.db')
const db = drizzle(sqlite)

const app = new Hono()

app.get('/api/posts', async (c) => {
  const posts = await db.select().from(postsTable)
  return c.json(posts)
})

app.post('/api/posts', async (c) => {
  const { title, content } = await c.req.json()
  const result = await db.insert(postsTable).values({ title, content })
  return c.json(result, 201)
})

export default app

Beneficios de Rendimiento

Las APIs de HonoJS consistentemente superan a Express en benchmarks. Su sobrecarga mínima y la base de Estándares Web significan tiempos de respuesta más rápidos y menor uso de memoria. Para despliegues edge, el pequeño tamaño del bundle (bajo 20KB) se traduce en arranques en frío más rápidos.

Conclusión

HonoJS ofrece un enfoque refrescante para construir APIs web. Su combinación de simplicidad, rendimiento y flexibilidad de entorno de ejecución lo convierte en una excelente opción para aplicaciones JavaScript modernas. Ya sea que estés construyendo microservicios, funciones serverless o APIs REST tradicionales, HonoJS proporciona las herramientas que necesitas sin la sobrecarga.

Comienza con una API simple, agrega middleware según sea necesario y despliega en cualquier lugar—esa es la forma de HonoJS.

Preguntas Frecuentes

Gain Debugging Superpowers

Unleash the power of session replay to reproduce bugs, track slowdowns and uncover frustrations in your app. Get complete visibility into your frontend with OpenReplay — the most advanced open-source session replay tool for developers. Check our GitHub repo and join the thousands of developers in our community.