Curso de Hono Framework

Crear un proyecto Hono con `npm create hono@latest`, pnpm, yarn, Bun o Deno según el entorno elegido.

Seleccionar plantillas adecuadas para Node.js, Bun, Deno, Cloudflare Workers, Vercel, AWS Lambda u otros runtimes.

Revisar estructura inicial del proyecto: `src`, entry point, configuración TypeScript, scripts y dependencias.

Configurar TypeScript con `tsconfig.json`, módulos ES, resolución de imports y strict mode.

Preparar scripts de desarrollo, build, test, lint, format y deploy.

Instalar herramientas habituales: ESLint, Prettier, Vitest, tsx, dotenv, wrangler, adapters o SDKs cloud.

Crear una primera aplicación Hono con endpoint raíz y respuesta de texto o JSON.

Ejecutar servidor local según runtime: Node.js, Bun, Deno o emulador de plataforma.

Resolver problemas frecuentes de versión de Node.js, módulos ESM, imports, templates y dependencias.

Preparar un repositorio Git base con README, `.gitignore`, estructura inicial y convenciones de proyecto.

Crear rutas GET, POST, PUT, PATCH, DELETE y OPTIONS con handlers claros y separados.

Trabajar rutas estáticas, rutas dinámicas, parámetros de path, query params y wildcard routes.

Organizar endpoints por recursos: usuarios, productos, pedidos, sesiones, incidencias o entidades de negocio.

Diseñar rutas REST con nombres coherentes, pluralización, jerarquías, status codes y payloads consistentes.

Usar route grouping y composición de subaplicaciones para dividir módulos funcionales.

Montar routers por dominio sin crear un único archivo gigante de rutas.

Gestionar rutas no encontradas con `notFound` y respuestas uniformes.

Crear convenciones para versionado de API: `/api/v1`, `/api/v2` o versionado por headers cuando procede.

Evitar rutas ambiguas, endpoints con demasiadas responsabilidades y handlers mezclados con lógica de negocio.

Realizar ejercicio de diseño de API REST modular para una aplicación empresarial.

Comprender el objeto `Context` como punto central para acceder a request, response, variables, bindings y helpers.

Leer parámetros de ruta, query params, headers, body, form data, JSON y cookies.

Crear respuestas con `c.text`, `c.json`, `c.html`, `c.redirect`, status codes y headers personalizados.

Diferenciar Request estándar, HonoRequest, Context y Response para evitar confusiones al diseñar servicios.

Manipular headers de respuesta para caché, seguridad, contenido, CORS y trazabilidad.

Trabajar con `c.req.valid` cuando existe validación previa.

Utilizar variables de contexto para pasar datos entre middleware y handlers.

Crear respuestas de error uniformes con estructura, código, mensaje, detalles y request ID.

Entender cómo Web Standards facilitan portabilidad entre Cloudflare Workers, Node.js, Bun y Deno.

Realizar ejercicio de endpoints que procesan JSON, parámetros, headers y respuestas tipadas.

Dividir la aplicación en módulos por dominio, feature, capa o recurso.

Separar rutas, handlers, servicios, repositorios, esquemas, middlewares, tipos y utilidades.

Crear subaplicaciones Hono montadas bajo prefijos como `/api/users`, `/api/auth` o `/api/admin`.

Diseñar composición de rutas manteniendo inferencia de tipos para RPC y clientes tipados.

Evitar acoplar handlers HTTP directamente a lógica de base de datos compleja.

Crear servicios reutilizables que puedan probarse sin levantar el servidor.

Gestionar dependencias mediante factories, context variables o patrones simples sin sobreingeniería.

Definir estructura escalable para equipos: `routes`, `modules`, `middlewares`, `lib`, `schemas`, `tests` y `infra`.

Documentar convenciones de proyecto para que nuevos desarrolladores entiendan dónde añadir código.

Refactorizar una app monolítica Hono hacia arquitectura modular.

Comprender el ciclo middleware-handler y el uso de `next()` para continuar procesamiento.

Aplicar middlewares globales, por path, por método o por grupo de rutas.

Entender el orden de ejecución y cómo afecta a logging, CORS, auth, validación y errores.

Crear middlewares propios para request ID, métricas, auditoría, inyección de dependencias o validación de permisos.

Pasar datos desde middleware a handlers mediante variables de contexto tipadas.

Cortar la ejecución devolviendo una respuesta desde middleware cuando procede.

Evitar middlewares demasiado grandes que mezclan seguridad, logging, lógica de negocio y validación.

Combinar middlewares integrados y personalizados de forma explícita y mantenible.

Documentar qué middleware aplica a cada zona de la API.

Realizar ejercicio de pipeline con logger, request ID, CORS, auth, validación y handler final.

Configurar CORS para frontends concretos, entornos de desarrollo, dominios corporativos y APIs públicas.

Evitar configuraciones CORS demasiado abiertas en endpoints privados o administrativos.

Usar logger para desarrollo y adaptar estrategia de logging en producción.

Aplicar secure headers para reforzar seguridad HTTP en endpoints y respuestas HTML.

Usar compression solo donde el runtime no comprime automáticamente o donde aporte valor real.

Medir tiempos con timing middleware y detectar endpoints lentos.

Configurar pretty JSON para desarrollo sin afectar producción.

Aplicar trailing slash y method override cuando el proyecto lo requiere.

Crear políticas por entorno: desarrollo, staging, producción, edge y serverless.

Realizar laboratorio de hardening básico de una API Hono con middlewares integrados.

Implementar Basic Auth para endpoints internos, demos, healthchecks protegidos o zonas administrativas simples.

Implementar Bearer Auth para APIs internas, webhooks o servicios con token compartido.

Implementar JWT Auth con cabecera Authorization o cookie según arquitectura.

Firmar, verificar y renovar tokens JWT con criterios de expiración, issuer, audience y secret management.

Integrar proveedores externos mediante middleware de terceros: OAuth, OIDC, Auth.js, Clerk, Firebase, Cloudflare Access o JWKS.

Separar autenticación, autorización, roles, permisos y ownership de recursos.

Crear middleware de autorización para roles como admin, user, support, service o internal.

Proteger rutas sensibles y evitar confiar solo en validación frontend.

Gestionar errores 401 y 403 de forma clara y auditable.

Realizar ejercicio de API con login, JWT, rutas protegidas, roles y pruebas de permisos.

Validar body JSON, query params, path params, headers y form data antes de ejecutar lógica de negocio.

Usar validator integrado de Hono para casos simples y control directo.

Integrar Zod, Valibot, ArkType, TypeBox u otras librerías compatibles según estándar del proyecto.

Crear esquemas reutilizables para DTOs, filtros, paginación, creación, actualización y respuestas.

Devolver errores de validación consistentes con código, campo, mensaje y detalle.

Diferenciar validación de entrada, validación de negocio y validación de persistencia.

Evitar esquemas duplicados entre backend, frontend, tests y documentación.

Tipar `c.req.valid` para que handlers reciban datos ya validados.

Crear validaciones para fechas, UUIDs, emails, enums, arrays, objetos anidados y paginación.

Realizar ejercicio de API validada con errores claros y contratos reutilizables.

Crear una estrategia centralizada de manejo de errores con `onError`.

Diferenciar errores de validación, autenticación, autorización, negocio, infraestructura y errores inesperados.

Usar HTTPException cuando conviene devolver errores HTTP controlados.

Crear formato estándar de error con `code`, `message`, `details`, `requestId` y `timestamp`.

Evitar exponer stack traces, secrets, SQL, tokens o información interna en producción.

Registrar errores con contexto suficiente para debugging y observabilidad.

Mapear errores de base de datos, servicios externos y validadores a respuestas HTTP.

Crear errores de dominio independientes del framework para mejorar testabilidad.

Diseñar páginas o respuestas not found, forbidden, bad request e internal error.

Realizar ejercicio de API con error handler global y catálogo de errores uniforme.

Comprender Hono RPC como mecanismo para compartir especificación de API entre servidor y cliente.

Exportar `AppType` o tipos de rutas para que el cliente infiera inputs y outputs.

Crear cliente tipado con `hc` y consumir endpoints desde frontend, Node.js u otro cliente TypeScript.

Aprovechar inferencia de tipos desde validadores y respuestas `c.json`.

Diseñar rutas para que la inferencia RPC sea útil, estable y fácil de mantener.

Evitar patrones que rompen inferencia por handlers demasiado dinámicos o respuestas inconsistentes.

Separar API pública documentada con OpenAPI de APIs internas con RPC tipado cuando procede.

Gestionar errores, status codes y tipos de respuesta en clientes RPC.

Crear monorepo o workspace compartido para backend y frontend con tipos consistentes.

Realizar ejercicio de frontend TypeScript consumiendo API Hono con RPC end-to-end type-safe.

Generar documentación OpenAPI usando middleware y librerías compatibles con validadores como Zod o Valibot.

Diseñar rutas con descripción, tags, parámetros, request body, responses y ejemplos.

Publicar documentación interactiva con Swagger UI, Scalar u otra herramienta compatible.

Mantener OpenAPI como contrato vivo y no como documentación escrita a mano sin sincronización.

Diferenciar RPC interno de documentación OpenAPI para terceros, partners o equipos no TypeScript.

Versionar especificaciones y documentar cambios breaking.

Crear ejemplos de payload correctos, errores, paginación, filtros y autenticación.

Integrar generación de OpenAPI en CI para detectar roturas de contrato.

Evitar documentar endpoints incompletos, inseguros o experimentales como API estable.

Realizar ejercicio de API documentada con OpenAPI, validación y cliente externo.

Integrar Hono con bases de datos SQL como PostgreSQL, MySQL, SQLite o servicios serverless.

Usar ORMs o query builders como Drizzle, Prisma, Kysely o acceso SQL directo según el runtime y la necesidad.

Diseñar capa de repositorio o data access separada de handlers HTTP.

Gestionar conexiones en Node.js, serverless y edge evitando patrones que agotan conexiones.

Trabajar con migraciones, seeds, transacciones y consistencia de datos.

Validar entrada antes de persistir y validar salida antes de responder.

Gestionar errores de constraints, claves únicas, registros no encontrados y conflictos.

Diseñar paginación, filtros, ordenación, búsqueda y respuestas parciales.

Usar servicios edge-friendly como Cloudflare D1, KV, Durable Objects, R2, Neon, Turso, Supabase o PlanetScale cuando encaja.

Realizar ejercicio de API CRUD conectada a base de datos con validación, errores y tests.

Consumir APIs externas con fetch estándar desde handlers o servicios.

Diseñar clientes HTTP internos para servicios externos con timeout, retries, errores y logging.

Validar webhooks entrantes con firma, secret, timestamp y replay protection.

Crear endpoints de webhook idempotentes para evitar duplicados por reintentos.

Gestionar respuestas lentas, servicios caídos, rate limits y errores 5xx.

Separar integración externa de lógica HTTP de Hono para facilitar tests.

Usar variables de entorno para URLs, tokens, claves y configuración por entorno.

Registrar llamadas externas sin exponer datos sensibles.

Crear jobs o procesos diferidos cuando un webhook no debe bloquearse.

Realizar ejercicio de integración con API externa y recepción segura de webhooks.

Leer y escribir cookies con helpers de Hono de forma segura.

Configurar atributos `HttpOnly`, `Secure`, `SameSite`, path, domain y expiración.

Diseñar sesiones stateless con JWT o sesiones stateful con almacenamiento externo según arquitectura.

Proteger formularios y endpoints sensibles frente a CSRF cuando se usan cookies.

Procesar `form-data`, `multipart/form-data` y formularios HTML.

Validar uploads y controlar tamaño de body con middleware adecuado.

Gestionar login, logout, expiración y rotación de sesión.

Diferenciar autenticación para SPA, SSR, API interna, mobile y server-to-server.

Evitar almacenar información sensible directamente en cookies sin cifrado o firma adecuada.

Realizar ejercicio de flujo de sesión con cookies seguras, CSRF y endpoint protegido.

Comprender cuándo usar streaming HTTP para respuestas largas, generación progresiva o procesamiento incremental.

Crear respuestas stream con Web Streams API y helpers de Hono.

Implementar Server-Sent Events para notificaciones, progreso de tareas o actualizaciones en tiempo real simples.

Evaluar WebSockets cuando se necesita comunicación bidireccional sostenida.

Controlar timeouts, cancelación, cierres de conexión y errores durante streaming.

Diseñar APIs que no bloqueen el runtime con tareas largas innecesarias.

Integrar streaming con servicios de IA, logs, progreso de importación o reporting.

Evitar streaming si el cliente, proxy o runtime no lo soporta de forma fiable.

Probar streaming en local y en plataforma de despliegue real.

Realizar ejercicio de endpoint SSE o streaming con progreso de proceso.

Usar Hono para devolver HTML y construir respuestas server-rendered ligeras.

Configurar JSX en proyectos Hono cuando se necesita renderizado de vistas simples.

Crear layouts, componentes, páginas y fragmentos reutilizables.

Combinar APIs JSON y páginas HTML en una misma app cuando el caso lo justifica.

Integrar JSX Renderer, html helper y middleware relacionado.

Servir formularios, paneles internos, landing pages o dashboards simples sin framework pesado.

Gestionar assets estáticos según runtime y plataforma.

Evitar convertir Hono en un framework full stack complejo si el proyecto requiere otra herramienta.

Comparar SSR ligero con SPA, Next.js, Astro o Remix según necesidades.

Realizar ejercicio de panel administrativo básico con HTML/JSX y endpoints JSON.

Aplicar secure headers, CORS restrictivo, CSRF, body limit, rate limiting externo y validación estricta.

Gestionar secrets con variables de entorno, plataformas cloud y gestores seguros.

Evitar logging de tokens, cookies, contraseñas, datos personales y payloads sensibles.

Diseñar respuestas de error que no filtren detalles internos.

Proteger endpoints administrativos, webhooks, jobs internos y healthchecks sensibles.

Revisar dependencias, middleware de terceros y librerías de autenticación.

Implementar controles de autorización por recurso, tenant, organización o usuario.

Diseñar auditoría de acciones críticas con request ID, usuario, IP, recurso y resultado.

Preparar checklist OWASP adaptado a APIs ligeras Hono.

Realizar ejercicio de hardening de una API vulnerable.

Crear tests unitarios para servicios, funciones, validadores y lógica de negocio.

Probar endpoints Hono sin levantar servidor real cuando el framework lo permite.

Usar `app.request` o clientes de test para validar status, JSON, headers y errores.

Crear tests de integración con base de datos de prueba, mocks o contenedores.

Probar middlewares de auth, CORS, errores, request ID y validación.

Generar fixtures, factories y datos de prueba reutilizables.

Validar OpenAPI o contratos para evitar cambios breaking.

Integrar tests en CI con lint, typecheck y build.

Medir cobertura con criterio sin perseguir porcentajes vacíos.

Realizar ejercicio de suite de tests para API REST modular.

Diseñar logging estructurado con request ID, método, path, status, duración y usuario cuando procede.

Diferenciar logs de desarrollo, logs de producción, auditoría, métricas y trazas.

Integrar Hono con Sentry, OpenTelemetry, plataformas cloud o sistemas de observabilidad.

Registrar errores externos, timeouts, validaciones fallidas y latencias anómalas.

Crear healthchecks, readiness checks y endpoints internos de diagnóstico.

Medir métricas clave: tasa de error, latencia p95/p99, throughput, cold starts y consumo de recursos.

Evitar logs ruidosos que no ayudan a resolver incidencias.

Diseñar troubleshooting por runtime: Node.js, Workers, Lambda, Vercel, Bun o Deno.

Crear runbooks para errores de despliegue, auth, base de datos, CORS y timeouts.

Realizar ejercicio de diagnóstico de una API con errores intermitentes.

Entender el router de Hono, coste de middleware, tamaño de bundle y latencia de respuesta.

Medir rendimiento antes de optimizar, usando herramientas de benchmark y métricas reales.

Reducir middlewares innecesarios en rutas críticas.

Optimizar validaciones, serialización JSON, consultas externas y acceso a base de datos.

Usar cache, ETag, headers de control y estrategias edge cuando el caso lo permite.

Diseñar endpoints idempotentes y cacheables donde sea posible.

Entender cold starts, warm starts, límites de CPU, memoria y duración en serverless.

Elegir runtime según patrón: edge global, Node.js tradicional, Bun, Deno, Lambda o Cloud Run.

Evitar optimizaciones micro que complican el código sin impacto medible.

Realizar ejercicio de profiling y optimización de endpoint lento.

Desplegar Hono en Node.js usando el adapter correspondiente y servidor HTTP.

Configurar Dockerfile para producción con build, dependencias, usuario no root y variables.

Ejecutar Hono con Bun cuando se busca rapidez de desarrollo o runtime alternativo.

Ejecutar Hono con Deno respetando permisos, imports y configuración del runtime.

Gestionar archivos estáticos, rutas, entorno y procesos de arranque.

Configurar graceful shutdown, healthchecks y logs en Node.js.

Preparar pipelines CI/CD para build, tests, typecheck y despliegue.

Comparar diferencias de runtime, dependencias, APIs disponibles y soporte operativo.

Resolver problemas de ESM, imports, adapters y compatibilidad de paquetes.

Realizar ejercicio de despliegue local y contenedorizado de una API Hono.

Crear proyecto Hono para Cloudflare Workers con Wrangler y bindings de entorno.

Usar Cloudflare KV, D1, R2 o Durable Objects cuando el diseño lo requiere.

Desplegar Hono en Vercel Functions o Edge según plantilla y limitaciones del proyecto.

Desplegar Hono en AWS Lambda con API Gateway, CDK o infraestructura equivalente.

Evaluar Lambda@Edge, Fastly Compute, Netlify, Azure Functions y Google Cloud Run según arquitectura.

Gestionar variables de entorno, secrets, dominios, routing y observabilidad en cada plataforma.

Adaptar static assets, streaming, caching y conexiones externas al runtime elegido.

Crear estrategia multi-runtime sin prometer portabilidad total cuando hay dependencias específicas.

Diseñar matriz de decisión de despliegue por coste, latencia, región, operación y compatibilidad.

Realizar laboratorio de despliegue en al menos dos runtimes distintos.

Diseñar Hono como API pública, API interna, BFF, gateway ligero, webhook receiver o microservicio.

Integrar Hono con frontends React, Vue, Svelte, Astro, Next.js o aplicaciones móviles.

Definir contratos de API, versionado, autenticación, rate limits y trazabilidad.

Aplicar patrones de arquitectura hexagonal o clean architecture sin sobrecargar el framework.

Diseñar servicios pequeños con responsabilidad clara y boundary funcional.

Integrar Hono con colas, eventos, cron jobs, workers y tareas diferidas.

Evaluar uso de Hono en monorepos con pnpm workspaces, Turborepo o Nx.

Crear librerías compartidas de tipos, validadores, clientes y utilidades.

Gestionar multi-tenant, organizaciones, permisos y separación de datos.

Diseñar checklist de producción para servicios Hono en empresa.

Comparar Hono con Express en simplicidad, tipos, Web Standards, middleware y portabilidad.

Comparar Hono con Fastify en rendimiento, plugins, ecosistema y estructura de proyecto.

Comparar Hono con NestJS en arquitectura opinionada, inyección de dependencias, learning curve y tamaño.

Comparar Hono con Elysia en Bun, tipado, rendimiento y ecosistema multi-runtime.

Comparar Hono con frameworks full stack cuando se necesita SSR, routing web, assets y frontend integrado.

Decidir cuándo Hono es ideal para APIs pequeñas, servicios edge, webhooks, BFFs o backends serverless.

Identificar riesgos de adoptar Hono en equipos acostumbrados a frameworks enterprise más estructurados.

Crear criterios de adopción por equipo: experiencia TypeScript, runtime objetivo, seguridad, observabilidad y mantenimiento.

Diseñar estrategia de migración desde Express/Fastify a Hono por módulos.

Preparar recomendación técnica para dirección o comité de arquitectura.

Crear una API profesional con Hono, TypeScript, estructura modular, validación, seguridad y despliegue real.

Diseñar dominio funcional con usuarios, autenticación, recursos protegidos, operaciones CRUD y reglas de negocio.

Configurar proyecto con `create-hono`, TypeScript strict, ESLint, Prettier, Vitest y estructura de carpetas profesional.

Implementar rutas REST versionadas con subaplicaciones Hono por módulo.

Crear middlewares de request ID, logging, CORS, secure headers, auth, roles y manejo de errores.

Diseñar esquemas de validación con Zod, Valibot u otra librería compatible.

Crear respuestas de error y éxito uniformes con status codes, mensajes, detalles y trazabilidad.

Integrar base de datos con capa de repositorio, migraciones y datos de prueba.

Implementar autenticación JWT o Bearer Auth con rutas públicas, privadas y administrativas.

Generar documentación OpenAPI con ejemplos, tags, request bodies, responses y errores.

Crear cliente RPC tipado para consumir la API desde un frontend o script TypeScript.

Implementar tests unitarios, tests de integración y pruebas de endpoints.

Añadir observabilidad con logs estructurados, métricas básicas, healthcheck y manejo de errores externos.

Optimizar endpoints críticos con caché, ETag, validación eficiente o consultas mejoradas.

Desplegar el proyecto en Node.js y en una plataforma serverless o edge como Cloudflare Workers, Vercel o AWS Lambda.

Documentar arquitectura, decisiones técnicas, seguridad, variables de entorno, despliegue, testing y mantenimiento.

Presentar la solución final defendiendo elección de runtime, estructura, contratos, seguridad, rendimiento y escalabilidad.