TypeScript

¿Por qué TypeScript?

TypeScript es JavaScript con tipos. Eso suena simple, pero en la práctica significa que una categoría entera de bugs — los que ocurren porque un valor no era lo que esperabas — se detectan mientras escribes código, no cuando tu cliente reporta un error en producción.

Para nuestros clientes esto significa software más confiable, entregas más rápidas (porque se pierde menos tiempo debuggeando) y aplicaciones que son más fáciles de mantener y evolucionar a lo largo de los años.

Cómo lo usamos

En todo nuestro desarrollo

TypeScript no es algo que usamos "a veces". Es nuestro estándar para todo el desarrollo:

• APIs backend con Node.js (Fastify, Express) — cada endpoint tiene tipos estrictos para request y response
• Aplicaciones frontend con Vue.js/Nuxt 3 — componentes tipados, composables con tipos y props validadas
• Integraciones — los conectores entre sistemas tienen tipos que describen exactamente la estructura de datos de cada lado
• Scripts de automatización — incluso los scripts de automatización usan TypeScript cuando la complejidad lo justifica

Validación end-to-end con Zod

Combinamos TypeScript con Zod para que los tipos no solo existan en compilación — también validen datos en tiempo de ejecución. Esto es crítico en APIs que reciben datos de fuentes externas (webhooks, formularios, integraciones):

import { z } from 'zod'

// El schema define la estructura Y la validación
const ClienteSchema = z.object({
  rfc: z.string().regex(/^[A-ZÑ&]{3,4}\d{6}[A-Z\d]{3}$/),
  razon_social: z.string().min(1).max(200),
  regimen_fiscal: z.string().length(3),
  uso_cfdi: z.enum(['G01', 'G03', 'P01', 'S01']),
  email: z.string().email(),
  credito: z.object({
    limite: z.number().nonnegative(),
    dias_plazo: z.number().int().min(0).max(120),
  }).optional(),
})

// TypeScript infiere el tipo automáticamente
type Cliente = z.infer<typeof ClienteSchema>

// En la API: valida datos reales contra el schema
app.post('/api/clientes', async (req) => {
  const cliente = ClienteSchema.parse(req.body) // ← Valida en runtime
  return await crearCliente(cliente)             // ← Tipado en compilación
})

Contratos de datos entre equipos

Cuando frontend y backend comparten tipos (end-to-end type safety), los errores de integración desaparecen. Si el backend cambia la estructura de una respuesta, el frontend detecta el error inmediatamente en compilación — no cuando un usuario ve datos rotos en pantalla.

Esto es particularmente valioso en proyectos donde:

• Un equipo desarrolla el backend (API) y otro el frontend (portal, app móvil)
• Hay integraciones entre múltiples sistemas que comparten estructuras de datos
• El proyecto va a crecer y evolucionar durante años y necesita ser mantenible

Migración de JavaScript a TypeScript

Para clientes que tienen aplicaciones JavaScript existentes que se han vuelto difíciles de mantener, hacemos migraciones graduales:

1. Configuramos TypeScript en modo estricto incremental (strict: false inicial)
2. Renombramos archivos .js a .ts uno por uno, empezando por los más críticos
3. Agregamos tipos a las funciones y estructuras más importantes
4. Subimos gradualmente el nivel de estrictez hasta llegar a strict: true
5. El resultado: la misma aplicación, pero con tipos que protegen contra regresiones

TypeScript + nuestro stack

TypeScript es el hilo conductor de nuestro desarrollo:

• Node.js — todo nuestro backend corre con TypeScript sobre Node.js
• Vue.js / Nuxt 3 — componentes y composables tipados con soporte nativo de TypeScript
• PostgreSQL — Prisma ORM genera tipos automáticamente desde el esquema de la base de datos
• Docker — multi-stage builds que compilan TypeScript a JavaScript optimizado para producción
• CI/CD — el compilador de TypeScript corre en el pipeline y bloquea el deploy si hay errores de tipo

¿Para qué tipo de empresa?

TypeScript no es una decisión que el cliente toma directamente — es parte de nuestro estándar de calidad. Pero es especialmente valioso para:

• Proyectos de largo plazo — aplicaciones que van a mantenerse y evolucionar durante años necesitan código tipado que cualquier desarrollador pueda entender
• Equipos grandes o distribuidos — los tipos funcionan como documentación viviente que mantiene a todos en la misma página
• Aplicaciones críticas — ERP, facturación, e-commerce y cualquier sistema donde un bug de tipo puede significar datos incorrectos o dinero perdido
• Empresas que quieren migrar JavaScript legacy — convertir gradualmente código frágil en código robusto sin reescribir desde cero