Fastify

Backend
Descripción general

Fastify es un framework de Backend para node.js centrado en el rendimiento, la baja sobrecarga y la extensibilidad. Es una alternativa moderna a Express con mejor manejo de asincronía y validación de esquemas mediante JSON Schema.

Permite construir APIs rápidas y modulares, compatibles tanto con servicios REST como con GraphQL, y ofrece una arquitectura basada en plugins para ampliar funcionalidades como bases de datos, autenticación, validación y más.

Características principales

Rendimiento alto: diseñado para manejar miles de solicitudes por segundo con baja latencia.
Extensible por plugins: cada módulo (DB, auth, cache, logger, etc.) puede añadirse como un plugin aislado.
Validación integrada con JSON Schema, permitiendo respuestas y entradas seguras.
Encapsulación de contextos: los plugins no interfieren entre sí, evitando colisiones globales.
Compatibilidad con REST, GraphQL y arquitecturas Microservicios.
Tipado y DX mejorada con soporte completo para TypeScript.

Uso básico

Instalación

npm install fastify

Servidor básico

// server.js
import Fastify from 'fastify'

const fastify = Fastify({
	logger: true
})

fastify.get('/', async (request, reply) => {
	return { message: 'Hola desde Fastify' }
})

fastify.listen({ port: 3000 })

Manejo de rutas

fastify.get('/users', async (req, reply) => {
	return [{ id: 1, name: 'Eduardo' }]
})

fastify.post('/users', async (req, reply) => {
	const user = req.body
	return { id: Date.now(), ...user }
})

Integración con GraphQL

Fastify puede integrarse fácilmente con Mercurius para exponer endpoints GraphQL con resolvers y esquemas.

npm install mercurius

import Fastify from 'fastify'
import mercurius from 'mercurius'

const app = Fastify()

const schema = `
	type Query {
		hello: String
	}
`

const resolvers = {
	Query: {
		hello: async () => 'Hola desde GraphQL en Fastify'
	}
}

app.register(mercurius, {
	schema,
	resolvers,
	graphiql: true
})

app.listen({ port: 3000 })

Plugins y extensibilidad

Fastify tiene un ecosistema de plugins oficial y comunitario:

@fastify/jwt → autenticación con JWT.
@fastify/cors → configuración CORS.
@fastify/static → servir archivos estáticos.
@fastify/mongodb o @fastify/postgres → conexión con bases de datos.
@fastify/formbody → parseo de formularios.

Ejemplo de plugin personalizado

async function userPlugin(fastify, options) {
	fastify.get('/profile', async () => {
		return { user: 'admin', role: 'root' }
	})
}

export default userPlugin

Registro del plugin:

fastify.register(userPlugin)

Buenas prácticas

Definir esquemas JSON para cada ruta (schema en el objeto de ruta).
Dividir rutas y plugins en módulos independientes.
Usar fastify-autoload para carga automática de plugins.
Habilitar logs estructurados con pino para observabilidad.
Aprovechar hooks (onRequest, preHandler, onSend, etc.) para auditoría y seguridad.

Casos de uso comunes

Microservicios orientados a eventos.
Gateways API combinando REST y GraphQL.
Aplicaciones serverless con despliegue en AWS Lambda, Azure Functions o Vercel.
Backends modulares con conexión a PostgreSQL, MongoDB o Redis.

Recursos y enlaces útiles

Documentación oficial: https://fastify.dev
Plugins: https://fastify.dev/ecosystem
Ejemplos: https://github.com/fastify/examples
Soporte TypeScript: https://fastify.dev/docs/latest/Reference/TypeScript

Fastify– Conceptos avanzados y ecosistema

Arquitectura interna

Fastify se basa en una arquitectura encapsulada: cada instancia tiene su propio contexto aislado, lo que permite construir jerarquías de servidores y plugins sin interferencias.
Esto facilita la creación de microservicios modulares, donde cada servicio o plugin puede tener su configuración, decoradores y dependencias separadas.

Ciclo de vida

El ciclo de vida de una petición en Fastify incluye múltiples hooks:

onRequest → se ejecuta antes del parseo.
preParsing → manipulación del request.
preValidation → validación previa.
preHandler → lógica intermedia o middleware.
preSerialization → transformación antes de enviar respuesta.
onSend → modificación del cuerpo de respuesta.
onResponse → tareas post-respuesta.

Estos hooks permiten instrumentar métricas, logging, caché o auditoría sin afectar el flujo de negocio.

Manejo de rendimiento

Fastify optimiza internamente la serialización JSON mediante Fast JSON Stringify, logrando una mejora significativa frente a JSON.stringify().
Además:

Minimiza los overheads de middlewares con un árbol de rutas precompilado.
Permite control fino del payload y del logging.
Dispone de integración nativa con HTTP/2, keep-alive y streaming.

Benchmark interno

Hasta 2x–3x más rápido que Express.
Latencias típicas < 100μs en respuestas simples.

Validación de datos

Fastify usa Ajv para validar datos mediante esquemas JSON:

Validación de parámetros (query, params, body, headers).
Autogeneración de documentación OpenAPI (con @fastify/swagger).
Filtros automáticos de propiedades desconocidas (removeAdditional).

Ejemplo con validación

fastify.route({
	method: 'POST',
	url: '/login',
	schema: {
		body: {
			type: 'object',
			required: ['user', 'password'],
			properties: {
				user: { type: 'string' },
				password: { type: 'string' }
			}
		}
	},
	handler: async (req, reply) => {
		const { user, password } = req.body
		return { token: `jwt-${user}` }
	}
})

Decoradores y encapsulación

Los decoradores permiten extender funcionalidades del servidor o del request/reply.

fastify.decorate('utils', {
	hashPassword(pwd) {
		return Buffer.from(pwd).toString('base64')
	}
})

fastify.get('/hash', (req, reply) => {
	return fastify.utils.hashPassword('1234')
})

Los decoradores se propagan a las instancias hijas.
No se sobrescriben automáticamente; si se requiere, se usa decorateRequest o decorateReply.

Registro y logging

Fastify usa Pino como logger predeterminado:

Logs estructurados en JSON.
Soporte para niveles (info, error, warn).
Integración con APMs o plataformas de observabilidad (Elastic, Datadog, Grafana Loki).

Ejemplo

const fastify = Fastify({
	logger: {
		level: 'info',
		transport: {
			target: 'pino-pretty',
			options: { colorize: true }
		}
	}
})

Testing y herramientas de desarrollo

fastify.inject() permite probar rutas sin servidor real.
Compatible con frameworks como Jest, Vitest o Tap.
Plugins recomendados para DX:
- @fastify/autoload: carga automática de módulos.
- @fastify/env: gestión de variables de entorno.
- @fastify/helmet: seguridad HTTP.

Ejemplo de test

import Fastify from 'fastify'
import t from 'tap'

const app = Fastify()
app.get('/', async () => ({ ok: true }))

t.test('root route', async t => {
	const res = await app.inject({ url: '/' })
	t.equal(res.statusCode, 200)
})

Seguridad

Fastify prioriza la seguridad con:

Headers seguros vía @fastify/helmet.
Protección CORS configurable.
Rate limiting con @fastify/rate-limit.
Validación estricta de entrada/salida.
JWT y OAuth2 mediante @fastify/jwt y @fastify/oauth2.

Escalabilidad y despliegue

Fastify es ideal para arquitecturas serverless o microservicios gracias a su bajo consumo y diseño modular.

Despliegue en entornos cloud

AWS Lambda: con @fastify/aws-lambda.
Azure Functions y Google Cloud Functions.
Docker y orquestadores como Kubernetes.
Escalabilidad horizontal con fastify-cluster.

Ejemplo básico de Dockerfile

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install --production
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Integraciones destacadas

ORMs: Prisma, TypeORM, Mongoose.
Caché: Redis o @fastify/caching.
Mensajería: RabbitMQ, Kafka, MQTT.
Observabilidad: @fastify/under-pressure, @fastify/metrics, @fastify/prometheus.

Patrones de diseño aplicados

Inversión de dependencias mediante plugins inyectables.
Builder pattern en la creación de instancias.
Decorator pattern en extensiones.
Encapsulated context como sustituto del singleton.

Casos avanzados

Gateways API con GraphQL y REST combinados.
Event-driven architecture con mensajería y colas.
Integración con gRPC o WebSocket para tiempo real.
Sistemas modulares basados en monorepo o DDD.

Conclusión

Fastify destaca por su equilibrio entre rendimiento, modularidad y ergonomía para el desarrollador. Es una opción sólida para construir backends escalables, tipados y mantenibles, compatibles con arquitecturas modernas orientadas a eventos, microservicios o nubes híbridas.

Fastify – Ecosistema ampliado y patrones profesionales

Ecosistema avanzado

Arquitectura modular con autoload

El plugin @fastify/autoload permite cargar automáticamente rutas, plugins y utilidades desde carpetas predefinidas.
Esto favorece una estructura de proyecto modular y mantenible, eliminando la necesidad de registrar manualmente cada módulo.

import AutoLoad from '@fastify/autoload'
import { join } from 'path'

fastify.register(AutoLoad, {
	dir: join(import.meta.dirname, 'plugins'),
	options: { prefix: '/api' }
})

Gestión de configuración

@fastify/env permite definir y validar variables de entorno de forma segura, garantizando que el servidor solo se inicie si las configuraciones son válidas.

await fastify.register(import('@fastify/env'), {
	schema: {
		type: 'object',
		required: ['PORT', 'DB_URL'],
		properties: {
			PORT: { type: 'number', default: 3000 },
			DB_URL: { type: 'string' }
		}
	},
	dotenv: true
})

Integración con arquitecturas empresariales

Domain Driven Design (DDD)

Fastify encaja perfectamente con DDD gracias a su aislamiento por contextos. Cada dominio puede implementarse como un plugin, encapsulando lógica, rutas y dependencias:

users/
payments/
notifications/
auth/

Cada dominio define su propio esquema, validaciones y controladores.

Clean Architecture y Hexagonal Architecture

Las dependencias externas (DB, APIs, eventos) se definen como adapters inyectados mediante plugins.
El core de negocio permanece independiente de la infraestructura.
Fastify actúa como capa de entrada, sin acoplar la lógica de dominio a los controladores HTTP.

Integración con mensajería y eventos

Eventos internos

Fastify ofrece un sistema de eventos mediante fastify.addHook() y fastify.emitter (en plugins externos), útil para auditorías, colas internas o instrumentación.

Mensajería externa

Integraciones con:

RabbitMQ mediante amqplib o @golevelup/nestjs-rabbitmq.
Kafka con librerías como kafkajs o @fastify/kafka.
MQTT para IoT o microservicios ligeros.

Ejemplo básico con RabbitMQ:

import amqp from 'amqplib'

fastify.decorate('publishEvent', async (queue, msg) => {
	const conn = await amqp.connect(process.env.AMQP_URL)
	const ch = await conn.createChannel()
	await ch.assertQueue(queue)
	ch.sendToQueue(queue, Buffer.from(JSON.stringify(msg)))
})

Documentación automática

Fastify puede generar documentación interactiva con @fastify/swagger y @fastify/swagger-ui.

await fastify.register(import('@fastify/swagger'), {
	openapi: {
		info: { title: 'API Docs', version: '1.0.0' }
	}
})
await fastify.register(import('@fastify/swagger-ui'))

Accesible en /documentation con esquemas generados automáticamente a partir de las rutas y validaciones JSON Schema.

Observabilidad y métricas

Monitoreo

Fastify se integra con sistemas de observabilidad mediante:

@fastify/metrics: exposición de métricas Prometheus.
@fastify/under-pressure: control de carga, heap y tiempo de respuesta.
Integración con Grafana, Prometheus, New Relic o Elastic APM.

Ejemplo de configuración:

await fastify.register(import('@fastify/under-pressure'), {
	maxEventLoopDelay: 1000,
	maxHeapUsedBytes: 100000000,
	message: 'Servidor saturado'
})

Despliegue y entornos productivos

Cluster y multihilo

Para entornos de alta concurrencia, puede usarse fastify-cluster o el módulo nativo cluster de Node.js:

import cluster from 'cluster'
import os from 'os'

if (cluster.isPrimary) {
	for (let i = 0; i < os.cpus().length; i++) cluster.fork()
} else {
	import('./server.js')
}

Esto permite escalar en múltiples núcleos sin perder encapsulación ni rendimiento.

Integración con Docker Compose

version: '3.8'
services:
	fastify:
		build: .
		ports:
			- "3000:3000"
		environment:
			- DB_URL=mongodb://mongo:27017/app
		depends_on:
			- mongo
	mongo:
		image: mongo:latest
		volumes:
			- ./data:/data/db

Integración con frontends

Fastify puede servir como backend para:

React o Next.js.
SvelteKit, Nuxt, Astro.
Aplicaciones Blazor WebAssembly o Blazor Hybrid mediante API REST o GraphQL.

También puede servir contenido estático:

await fastify.register(import('@fastify/static'), {
	root: new URL('./dist', import.meta.url).pathname
})

Extensión con CLI y tooling

Para proyectos grandes se recomienda:

Crear scripts CLI personalizados (con fastify-cli o zx).
Usar fastify printRoutes() para visualizar rutas activas.
Integrar eslint, ts-node-dev y nodemon para desarrollo ágil.

Patrones de despliegue avanzados

Serverless Edge con Cloudflare Workers o Vercel Functions.
Monorepos con Nx o Turborepo.
CI/CD con GitHub Actions o GitLab CI.

Integración con seguridad avanzada

Cifrado de tráfico interno (mutual TLS).
Autenticación distribuida con tokens rotativos.
Integración OAuth2 con proveedores como Google, GitHub, Auth0.
Control de sesiones mediante @fastify/session.

Internacionalización (i18n)

Mediante el plugin @fastify/i18n se pueden servir respuestas en varios idiomas:

await fastify.register(import('@fastify/i18n'), {
	locales: ['en', 'es', 'fr'],
	directory: './locales'
})

Migraciones y mantenimiento

@fastify/migrate o integración con Prisma Migrate para evolución de esquemas.
Versionado de APIs (/v1, /v2) con rutas independientes y gestión por prefijos.
Uso de fastify-plugin para marcar dependencias explícitas entre módulos.

Casos reales y escenarios

APIs empresariales con alta concurrencia (ERP, CRM, SaaS).
IoT Gateways por su baja latencia.
Backend de aplicaciones móviles con autenticación, caché y WebSockets.
Streaming o mensajería en tiempo real (chat, notificaciones, colas).

Conclusión ampliada

Fastify ha evolucionado hacia un ecosistema profesional capaz de competir con frameworks empresariales. Combina modularidad, velocidad, seguridad y compatibilidad con arquitecturas modernas. Su flexibilidad lo convierte en una base ideal para proyectos de largo recorrido, desde microservicios y APIs GraphQL hasta plataformas completas orientadas a eventos o serverless distribuidas.

Fastify – Integraciones profesionales y prácticas avanzadas

Integración con protocolos alternativos

WebSocket

Fastify no incluye WebSocket de forma nativa, pero se integra fácilmente con @fastify/websocket o librerías externas como ws.

import websocketPlugin from '@fastify/websocket'

await fastify.register(websocketPlugin)

fastify.get('/chat', { websocket: true }, (conn, req) => {
	conn.socket.on('message', msg => {
		conn.socket.send(`Echo: ${msg}`)
	})
})

Usos comunes:

Chat en tiempo real.
Monitorización de sensores o colas.
Sincronización de datos entre clientes.

gRPC y GraphQL Federation

Fastify puede actuar como gateway o servidor gRPC mediante @fastify/grpc, o federar servicios GraphQL usando @mercuriusjs/federation. Esto lo hace apto para arquitecturas multilenguaje y federadas, integrando varios backends.

Caché y rendimiento extremo

Capa de caché distribuida

Integración con Redis o Memcached usando @fastify/redis o @fastify/caching. Permite cachear respuestas REST o resolvers GraphQL para reducir carga de CPU y DB.

await fastify.register(import('@fastify/redis'), {
	host: 'localhost'
})

fastify.get('/data', async (req, reply) => {
	const cached = await fastify.redis.get('mydata')
	if (cached) return JSON.parse(cached)

	const data = await fetchData()
	await fastify.redis.set('mydata', JSON.stringify(data), 'EX', 60)
	return data
})

HTTP/2 y compresión

Soporta HTTP/2, gzip y brotli, mejorando la eficiencia en conexiones persistentes y móviles:

await fastify.register(import('@fastify/compress'), { global: true })

Integración con herramientas de desarrollo y CI/CD

Pipeline automatizado

Fastify se adapta a pipelines en GitHub Actions, GitLab CI o Azure DevOps:

Ejecución de tests con fastify.inject.
Linter + TypeScript check.
Deploy automático en contenedores o serverless.

name: CI
on: [push]
jobs:
	build:
		runs-on: ubuntu-latest
		steps:
			- uses: actions/checkout@v4
			- uses: actions/setup-node@v4
			  with:
				  node-version: 20
			- run: npm ci
			- run: npm test
			- run: docker build -t fastify-app .

Seguridad empresarial

Rate limiting distribuido

Con @fastify/rate-limit se puede limitar el número de peticiones por IP o usuario. Si se combina con Redis, puede aplicarse en clústeres o entornos distribuidos.

await fastify.register(import('@fastify/rate-limit'), {
	max: 100,
	timeWindow: '1 minute',
	cache: 10000
})

Integración OAuth2

Fastify permite autenticación social mediante @fastify/oauth2:

await fastify.register(import('@fastify/oauth2'), {
	name: 'githubOAuth2',
	scope: ['user:email'],
	credentials: {
		client: { id: process.env.GH_ID, secret: process.env.GH_SECRET },
		auth: fastify.OAuth2.GITHUB_CONFIGURATION
	},
	startRedirectPath: '/login/github',
	callbackUri: 'http://localhost:3000/login/github/callback'
})

Monitoreo avanzado y tracing distribuido

Integración con OpenTelemetry

Fastify ofrece soporte completo para trazabilidad distribuida mediante @opentelemetry/api o @opentelemetry/instrumentation-fastify. Permite rastrear solicitudes entre microservicios, incluyendo tiempos, errores y dependencias.

import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
import { registerInstrumentations } from '@opentelemetry/instrumentation'
import { FastifyInstrumentation } from '@opentelemetry/instrumentation-fastify'

const provider = new NodeTracerProvider()
registerInstrumentations({ instrumentations: [new FastifyInstrumentation()] })

Integración con colas y tareas asíncronas

Tareas diferidas

Fastify puede integrarse con colas asíncronas mediante BullMQ o Agenda para ejecutar trabajos fuera del ciclo de petición.

import { Queue } from 'bullmq'

const queue = new Queue('emails', { connection: { host: 'localhost' } })

fastify.post('/send', async (req, reply) => {
	await queue.add('sendEmail', { to: req.body.email })
	return { ok: true }
})

Esto permite:

Procesamiento en background.
Envío de emails o reportes.
Integración con microservicios de eventos.

Tipado y soporte TypeScript avanzado

Fastify expone tipado genérico para rutas, plugins y decoradores, facilitando la autocompletación en IDEs.

Ejemplo tipado

import Fastify, { FastifyInstance } from 'fastify'

const app: FastifyInstance = Fastify()

app.get<{ Params: { id: string } }>('/user/:id', async (req, reply) => {
	return { user: req.params.id }
})

Ventajas:

Validación de esquemas en tiempo de compilación.
Coherencia entre tipos de request/response.
Detección temprana de errores de API.

Patrón plugin distribuido

Para proyectos grandes, se recomienda dividir el código en:

core/ → lógica base del servidor.
plugins/ → extensiones comunes.
modules/ → dominios de negocio.
adapters/ → infraestructura (DB, colas, APIs externas).

Cada módulo se registra dinámicamente con fastify-autoload, favoreciendo el principio de inversión de dependencias y facilitando la reutilización entre servicios.

Integración con frameworks externos

NestJS + Fastify

Fastify puede actuar como motor HTTP dentro de NestJS:

import { NestFactory } from '@nestjs/core'
import { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify'
import { AppModule } from './app.module'

async function bootstrap() {
	const app = await NestFactory.create<NestFastifyApplication>(
		AppModule,
		new FastifyAdapter()
	)
	await app.listen(3000)
}
bootstrap()

Esto combina el ecosistema de NestJS (decoradores, DI, módulos) con la eficiencia de Fastify.

Escenarios de despliegue híbrido

Edge Computing y Serverless

Fastify se puede adaptar para ejecutarse en entornos sin servidor, como:

AWS Lambda (@fastify/aws-lambda)
Vercel Functions
Netlify Functions
Cloudflare Workers (usando adaptadores como fastly)

Esto permite reducir costes y mejorar latencia en entornos distribuidos globalmente.

Auditoría y cumplimiento normativo

Fastify puede integrarse con sistemas de auditoría:

Registro de cambios mediante hooks globales.
Exportación de logs firmados o encriptados.
Integración con herramientas de cumplimiento (GDPR, ISO 27001, PCI DSS).

Ejemplo:

fastify.addHook('onResponse', async (req, reply) => {
	await logToAuditSystem({
		method: req.method,
		url: req.url,
		status: reply.statusCode,
		time: reply.getResponseTime()
	})
})

Escenarios de integración de datos

Fastify puede actuar como API Gateway para múltiples fuentes:

REST externos.
SOAP (mediante adaptadores).
GraphQL federados.
gRPC o WebSocket.
Bases de datos mixtas (SQL + NoSQL).

Permite composición de servicios para unificar datos en una respuesta única optimizada para el cliente.

Ecosistema complementario

@fastify/error → gestión centralizada de errores.
@fastify/multipart → subida de archivos.
@fastify/view → renderizado de plantillas (EJS, Handlebars, Pug).
@fastify/formbody → parseo automático de formularios.
@fastify/sensible → utilidades comunes (httpErrors, getHeader, etc.).

Conclusión final

Fastify se ha consolidado como un framework de backend completo, flexible y empresarial, que abarca desde APIs ligeras hasta ecosistemas distribuidos complejos. Su filosofía basada en plugins, tipado, rendimiento y aislamiento lo hace ideal para desarrollos modernos orientados a microservicios, eventos y despliegue global en nubes híbridas o serverless.

Es una plataforma madura y sostenible para proyectos de larga duración, adaptable tanto a startups como a entornos corporativos de alta exigencia.

Fastify – Ejemplo completo de desarrollo (API modular con autenticación y base de datos)

Objetivo del proyecto

Construir una API REST modular con Fastify que incluya:

Registro y autenticación JWT.
Gestión de usuarios y tareas.
Conexión a base de datos PostgreSQL con Prisma.
Validación con JSON Schema.
Estructura escalable mediante plugins y módulos.

Estructura del proyecto

📦 fastify-api
┣ 📂 src
┃ ┣ 📂 plugins
┃ ┃ ┣ db.js
┃ ┃ ┗ auth.js
┃ ┣ 📂 modules
┃ ┃ ┣ 📂 users
┃ ┃ ┃ ┣ routes.js
┃ ┃ ┃ ┗ schema.js
┃ ┃ ┗ 📂 tasks
┃ ┃ ┃ ┣ routes.js
┃ ┃ ┃ ┗ schema.js
┃ ┗ server.js
┣ 📜 prisma/schema.prisma
┣ 📜 package.json
┗ 📜 .env

Configuración base

Instalación

npm init -y
npm install fastify @fastify/jwt @fastify/cors @fastify/env @fastify/autoload prisma @prisma/client
npx prisma init

`.env`

DATABASE_URL="postgresql://user:password@localhost:5432/fastifydb"
JWT_SECRET="supersecretkey"
PORT=3000

Definición del esquema de base de datos (Prisma)

prisma/schema.prisma

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  password  String
  tasks     Task[]
}

model Task {
  id        Int      @id @default(autoincrement())
  title     String
  completed Boolean  @default(false)
  userId    Int
  user      User     @relation(fields: [userId], references: [id])
}

Ejecuta las migraciones:

npx prisma migrate dev --name init

Plugin de base de datos

src/plugins/db.js

import fp from 'fastify-plugin'
import { PrismaClient } from '@prisma/client'

async function dbPlugin(fastify) {
	const prisma = new PrismaClient()
	fastify.decorate('db', prisma)
}

export default fp(dbPlugin)

Plugin de autenticación

src/plugins/auth.js

import fp from 'fastify-plugin'

async function authPlugin(fastify) {
	await fastify.register(import('@fastify/jwt'), {
		secret: process.env.JWT_SECRET
	})

	fastify.decorate('authenticate', async (req, reply) => {
		try {
			await req.jwtVerify()
		} catch (err) {
			reply.send(err)
		}
	})
}

export default fp(authPlugin)

Módulo de usuarios

Schema

src/modules/users/schema.js

export const userSchemas = {
	register: {
		body: {
			type: 'object',
			required: ['email', 'password'],
			properties: {
				email: { type: 'string', format: 'email' },
				password: { type: 'string', minLength: 6 }
			}
		}
	},
	login: {
		body: {
			type: 'object',
			required: ['email', 'password'],
			properties: {
				email: { type: 'string' },
				password: { type: 'string' }
			}
		}
	}
}

Rutas

src/modules/users/routes.js

import bcrypt from 'bcryptjs'
import { userSchemas } from './schema.js'

async function userRoutes(fastify) {
	fastify.post('/register', { schema: userSchemas.register }, async (req, reply) => {
		const { email, password } = req.body
		const existing = await fastify.db.user.findUnique({ where: { email } })
		if (existing) return reply.code(400).send({ message: 'Email ya registrado' })

		const hashed = await bcrypt.hash(password, 10)
		const user = await fastify.db.user.create({ data: { email, password: hashed } })
		return { id: user.id, email: user.email }
	})

	fastify.post('/login', { schema: userSchemas.login }, async (req, reply) => {
		const { email, password } = req.body
		const user = await fastify.db.user.findUnique({ where: { email } })
		if (!user) return reply.code(401).send({ message: 'Credenciales inválidas' })

		const valid = await bcrypt.compare(password, user.password)
		if (!valid) return reply.code(401).send({ message: 'Contraseña incorrecta' })

		const token = fastify.jwt.sign({ id: user.id, email: user.email })
		return { token }
	})
}

export default userRoutes

Módulo de tareas

Schema

src/modules/tasks/schema.js

export const taskSchemas = {
	create: {
		body: {
			type: 'object',
			required: ['title'],
			properties: {
				title: { type: 'string' }
			}
		}
	}
}

Rutas

src/modules/tasks/routes.js

import { taskSchemas } from './schema.js'

async function taskRoutes(fastify) {
	fastify.addHook('preHandler', fastify.authenticate)

	fastify.get('/', async (req) => {
		return fastify.db.task.findMany({ where: { userId: req.user.id } })
	})

	fastify.post('/', { schema: taskSchemas.create }, async (req) => {
		return fastify.db.task.create({
			data: { title: req.body.title, userId: req.user.id }
		})
	})

	fastify.put('/:id', async (req) => {
		return fastify.db.task.update({
			where: { id: Number(req.params.id) },
			data: { completed: true }
		})
	})

	fastify.delete('/:id', async (req) => {
		await fastify.db.task.delete({ where: { id: Number(req.params.id) } })
		return { message: 'Tarea eliminada' }
	})
}

export default taskRoutes

Servidor principal

src/server.js

import Fastify from 'fastify'
import AutoLoad from '@fastify/autoload'
import { join } from 'path'
import dotenv from 'dotenv'

dotenv.config()
const app = Fastify({ logger: true })

// Plugins globales
app.register(import('@fastify/cors'))
app.register(import('@fastify/env'), {
	schema: {
		type: 'object',
		required: ['PORT', 'JWT_SECRET', 'DATABASE_URL'],
		properties: {
			PORT: { type: 'number' },
			JWT_SECRET: { type: 'string' },
			DATABASE_URL: { type: 'string' }
		}
	},
	dotenv: true
})

// Autoload de plugins y módulos
app.register(AutoLoad, { dir: join(import.meta.dirname, 'plugins') })
app.register(AutoLoad, { dir: join(import.meta.dirname, 'modules') })

// Inicio del servidor
const start = async () => {
	try {
		await app.listen({ port: process.env.PORT })
		console.log(`🚀 Servidor corriendo en http://localhost:${process.env.PORT}`)
	} catch (err) {
		app.log.error(err)
		process.exit(1)
	}
}
start()

Pruebas rápidas con cURL

Registro de usuario

curl -X POST http://localhost:3000/users/register \
 -H "Content-Type: application/json" \
 -d '{"email": "user@test.com", "password": "123456"}'

curl -X POST http://localhost:3000/users/login \
 -H "Content-Type: application/json" \
 -d '{"email": "user@test.com", "password": "123456"}'

Crear tarea

curl -X POST http://localhost:3000/tasks \
 -H "Authorization: Bearer <TOKEN>" \
 -H "Content-Type: application/json" \
 -d '{"title": "Aprender Fastify"}'

Buenas prácticas aplicadas

Arquitectura modular con encapsulación de dominios.
Validación con JSON Schema.
Uso de hooks para autenticación global.
Persistencia con Prisma y PostgreSQL.
Separación de capas: plugins, módulos, rutas, esquemas.
Preparado para escalar en Docker o entornos Serverless.

Extensiones posibles

Integrar Swagger (@fastify/swagger) para documentación.
Añadir paginación y filtros a las tareas.
Implementar notificaciones con Redis o RabbitMQ.
Crear frontend con React, Blazor o SvelteKit consumiendo la API.

Conclusión

Este ejemplo demuestra una API completa, segura y escalable con Fastify. Combina modularidad, tipado y rendimiento, sirviendo como base para proyectos reales de tipo SaaS, aplicaciones móviles o microservicios distribuidos.

Fastify – Actualizaciones y temas emergentes (2025)

Versión 5 y ciclo de vida

Fastify v5 ya es la versión estable publicada en septiembre de 2024. :contentReference[oaicite:1]{index=1}
En esta versión: solo soporte para Node.js v20+. :contentReference[oaicite:3]{index=3}
Se elimina fastify v4 a partir del 30 de junio de 2025. :contentReference[oaicite:4]{index=4}
Guía de migración con cambios importantes como: esquemas JSON completos obligatorios, nuevo constructor de logger, cambios en APIs de rutas, etc. :contentReference[oaicite:5]{index=5}

Principios técnicos reafirmados

“Zero overhead in production” sigue siendo un pilar: mínima sobrecarga del framework. :contentReference[oaicite:6]{index=6}
Buena experiencia de desarrollador, modularidad, foco en microservicios/serverless. :contentReference[oaicite:7]{index=7}
Seguridad y validaciones como base obligatoria, no extras opcionales. :contentReference[oaicite:8]{index=8}

Seguridad, auditoría y estado 2025

Se publicó una auditoría de seguridad “Security Audit 2023-2024” del ecosistema Fastify que examina múltiples plugins oficiales. :contentReference[oaicite:9]{index=9}
Esto indica que aunque Fastify ofrece buen rendimiento, se debe estar atento a vulnerabilidades en plugins de terceros o configuración incorrecta.
Buenas prácticas emergentes en 2025: versiones de dependencias siempre actualizadas, validación de esquema rigurosa, prevención de contaminación de prototipos (req.params sin prototipo en v5) como medida de seguridad. :contentReference[oaicite:10]{index=10}

Ecosistema + métricas de adopción

El blog oficial indica que Fastify tiene un ecosistema creciente: cientos de plugins reconocidos (~296 en la fecha de publicación) y millones de descargas mensuales. :contentReference[oaicite:11]{index=11}
En rankings de frameworks Node.js para 2025, Fastify aparece como opción de alto rendimiento y alternativa seria frente a frameworks más convencionales. :contentReference[oaicite:12]{index=12}

Temas emergentes en adopción práctica

Integración con validadores como Zod o TypeBox, aunque Fastify continúa con soporte para JSON Schema / Ajv. En debates de desarrolladores se destaca que “Usamos JSON Schema pero el soporte TS no es tan ideal al usar Zod”. :contentReference[oaicite:15]{index=15}
Plantillas y arranques (boilerplates) para Fastify + TypeScript + Docker ya son comunes (2025) en la comunidad. :contentReference[oaicite:16]{index=16}
Estructuras de carpetas, monorepos, microservicios y arquitecturas distribuidas con Fastify están más maduras: combinar varios servicios, usar Fastify como gateway, etc.

Recomendaciones específicas para 2025

Si usas Fastify v5: asegúrate de que todo tu código y plugins sean compatibles con Node.js v20+ y con los nuevos requisitos de esquema JSON.
Revisa los plugins que uses: algunos podrían no haber sido revisados en la auditoría reciente. Mantén dependencias actualizadas.
Aprovéchate de los channels de diagnóstico (diagnostics_channel) que ahora Fastify v5 soporta nativamente para traza de ciclo de vida de peticiones. :contentReference[oaicite:17]{index=17}
Aprovecha la tipificación con TypeScript, pero conoce sus límites: algunos desarrolladores señalan que decorar instancias Fastify desde TS requiere definiciones manuales. :contentReference[oaicite:18]{index=18}
Considera arquitecturas de backend modernas (microservicios, serverless, edge) y usa Fastify con consciencia de rendimiento, modularidad y carga de plugins ligera.

Resumen final

Aunque ya habíamos cubierto los conceptos generales, los temas actualizados a 2025 dan un contexto clave: versión 5, enfoque en node v20+, auditoría de seguridad reciente, ecosistema creciente, y prácticas emergentes en validación/plantillas.
Con estos añadidos, la nota queda bastante completa para uso profesional actual.

Aquí tienes una lista ampliada de plugins para Fastify, con su estado al 2025 (o lo más actualizado posible). Puedes usarla como referencia rápida para ver opciones, compatibilidad y categoría (core vs comunidad).

Nota: “estado” se refiere en gran parte a que están listados en el ecosistema oficial o tienen actividad reciente; siempre conviene verificar el repositorio, último commit, issues abiertos, etc.

✅ Plugins “core” (mantenidos por el equipo de Fastify)

Estos son plugins oficiales que el equipo de Fastify indica como mantenidos. (fastify.dev)

@fastify/accepts — añade método accepts al request. (fastify.dev)
@fastify/accepts-serializer — serialización basada en header Accept. (fastify.dev)
@fastify/auth — permite combinar múltiples funciones de autenticación. (fastify.dev)
@fastify/autoload — carga automática de plugins desde carpetas. (fastify.dev)
@fastify/awilix — soporte de inyección de dependencias vía Awilix. (fastify.dev)
@fastify/aws-lambda — despliegue serverless en AWS Lambda/Api Gateway. (fastify.dev)
@fastify/basic-auth — autenticación básica (user/password). (fastify.dev)
@fastify/bearer-auth — autenticación vía bearer token. (fastify.dev)
@fastify/caching — caché del lado servidor + control de cabeceras ETag. (ostif.org)
@fastify/circuit-breaker — plugin para “circuit breaker” en rutas HTTP. (fastify.dev)
@fastify/compress — compresión (gzip/brotli) para respuestas. (ostif.org)
@fastify/cookie — parseo y setting de cookies. (ostif.org)
@fastify/cors — habilitar CORS. (ostif.org)
@fastify/csrf-protection — protección CSRF (cross-site request forgery) para formularios. (fastify.dev)
@fastify/kafka — integración con Apache Kafka. (fastify.dev)
@fastify/mongodb — conexión a MongoDB, pool compartido. (fastify.dev)
@fastify/multipart — soporte multipart/form-data (subida de archivos). (fastify.dev)
@fastify/mysql — conexión a MySQL. (fastify.dev)
@fastify/postgres — conexión a PostgreSQL. (fastify.dev)
@fastify/rate-limit — limitador de peticiones para rutas. (fastify.dev)
@fastify/redis — conexión a Redis para caché o pub/sub. (fastify.dev)
@fastify/secure-session — sesiones seguras “stateless”. (fastify.dev)
@fastify/static — servir archivos estáticos lo más rápido posible. (fastify.dev)
@fastify/swagger — generar documentación OpenAPI/Swagger dinámicamente. (fastify.dev)
@fastify/websocket — soporte WebSocket basado en ws. (fastify.dev)
@fastify/type-provider-json-schema-to-ts — tipado para rutas mediante JSON Schema → TypeScript. (fastify.dev)
@fastify/type-provider-typebox — otro proveedor de tipos para TypeBox. (fastify.dev)
@fastify/under-pressure — monitorizar carga de proceso, permitir respuestas “503 Service Unavailable”. (fastify.dev)
@fastify/vite — integración con Vite para SSR/SPA/MPA. (fastify.dev)

🔍 Plugins de la comunidad (“community”)

Estos no son mantenidos directamente por el equipo de Fastify, por lo tanto su estado depende de cada autor/maintainer. Usar con más precaución. (fastify.dev)

@aaroncadillac/crudify-mongo — CRUD automático con Mongo para Fastify. (fastify.dev)
@clerk/fastify — autenticación y user-management usando Clerk con Fastify. (fastify.dev)
@coobaha/typed-fastify — rutas fuertemente tipadas con validación runtime generada desde types. (fastify.dev)
@exortek/fastify-mongo-sanitize — protección NoSQL-injection vía sanitización de inputs. (fastify.dev)
@eropple/fastify-openapi3 — generación de OpenAPI 3.1 desde rutas Fastify. (fastify.dev)
fastify-sqLite, fastify-sqlite-typed — soporte SQLite con tipado para TS. (fastify.dev)
fastify-stripe — integración con Stripe desde Fastify. (fastify.dev)
fastify-supabase — integración con Supabase (back-end as a service) desde Fastify. (fastify.dev)
fastify-sse, fastify-sse-v2 — Server-Sent Events (SSE) para streaming de datos. (fastify.dev)
fastify-tokenize — manejo de tokens de autenticación desde Fastify (integrado con fastify-auth). (fastify.dev)
Otros muchos: fastify-response-caching, fastify-rabbitmq, fastify-mqtt, fastify-kysely, etc. (fastify.dev)

🛠 Estado clave y recomendaciones al 2025

La versión Fastify v5 ya está oficialmente publicada (septiembre 2024) y ha eliminado soporte para Node.js < v20. (OpenJS Foundation)
En la auditoría de seguridad “Security Audit 2023-2024” se analizaron varios de los plugins core anteriores (por ejemplo @fastify/caching, @fastify/compress, @fastify/cookie, @fastify/cors). (ostif.org)
Aunque un plugin esté listado en el ecosistema oficial, eso no garantiza mantenimiento activo — siempre conviene revisar el repositorio, issues abiertos, última versión publicada, compatibilidad con v5.
Para proyectos nuevos con Fastify v5: prioriza plugins core o comunidad con confirmada compatibilidad con v5 (o versión reciente) y que indiquen soporte para Node v20+.
Verifica especialmente: compatibilidad con TypeScript (si usas TS), pruebas unitarias, cobertura de test, mantenimiento reciente.

Si quieres, puedo generar una tabla completa (por ejemplo 50 plugins relevantes) con columna “Compatibilidad v5”, “Última versión”, “Estado de mantenimiento” y “Categoría (core/comunidad)” para ayudarte a elegir. ¿Te la preparo?

Fastify

Descripción general

Características principales

Uso básico

Instalación

Servidor básico

Manejo de rutas

Integración con GraphQL

Plugins y extensibilidad

Ejemplo de plugin personalizado

Buenas prácticas

Casos de uso comunes

Recursos y enlaces útiles

Fastify– Conceptos avanzados y ecosistema

Arquitectura interna

Ciclo de vida

Manejo de rendimiento

Benchmark interno

Validación de datos

Ejemplo con validación

Decoradores y encapsulación

Registro y logging

Ejemplo

Testing y herramientas de desarrollo

Ejemplo de test

Seguridad

Escalabilidad y despliegue

Despliegue en entornos cloud

Ejemplo básico de Dockerfile

Integraciones destacadas

Patrones de diseño aplicados

Casos avanzados

Conclusión

Fastify – Ecosistema ampliado y patrones profesionales

Ecosistema avanzado

Arquitectura modular con autoload

Gestión de configuración

Integración con arquitecturas empresariales

Domain Driven Design (DDD)

Clean Architecture y Hexagonal Architecture

Integración con mensajería y eventos

Eventos internos

Mensajería externa

Documentación automática

Observabilidad y métricas

Monitoreo

Despliegue y entornos productivos

Cluster y multihilo

Integración con Docker Compose

Integración con frontends

Extensión con CLI y tooling

Patrones de despliegue avanzados

Integración con seguridad avanzada

Internacionalización (i18n)

Migraciones y mantenimiento

Casos reales y escenarios

Conclusión ampliada

Fastify – Integraciones profesionales y prácticas avanzadas

Integración con protocolos alternativos

WebSocket

gRPC y GraphQL Federation

Caché y rendimiento extremo

Capa de caché distribuida

HTTP/2 y compresión

Integración con herramientas de desarrollo y CI/CD

Pipeline automatizado

Seguridad empresarial

Rate limiting distribuido

Integración OAuth2

Monitoreo avanzado y tracing distribuido

Integración con OpenTelemetry

Integración con colas y tareas asíncronas

Tareas diferidas

Tipado y soporte TypeScript avanzado

Ejemplo tipado

Patrón plugin distribuido

Integración con frameworks externos

NestJS + Fastify

Escenarios de despliegue híbrido

Edge Computing y Serverless

`.env`