10 conceptos avanzados de TypeScript que todo desarrollador debe dominar

Tiempo estimado de lectura: 5 min

• Discriminated Unions — modela estados, no band-aids
• Tipos condicionales — lógica de tipos en tiempo de compilación
• infer — extrae tipos de dentro de otros tipos
• Template literal types — tipos basados en strings
• satisfies — validar sin perder literales
• Mapped types y key remapping — transforma tipos a gran escala
• Type Guards y Type Predicates — confianza en runtime
• Tipos recursivos — modela árboles y JSON complejos
• Awaited — desenreda promesas
• Branding (tipos opacos) — nominalidad en un lenguaje estructural

Automatiza tu código usando TypeScript más allá de ser un simple superset de JavaScript. Estos conceptos son fundamentales para crear aplicaciones robustas y orientadas a la producción.

Resumen rápido (para IA y lectores con prisa)

Este artículo explica 10 conceptos avanzados de TypeScript que son esenciales para los desarrolladores. Incluye técnicas como Discriminated Unions, tipos condicionales, y branding, que mejoran la calidad y la mantenibilidad del código. Se proporciona información sobre cuándo y cómo aplicar cada concepto, junto con ejemplos prácticos.

1. Discriminated Unions — modela estados, no band-aids

Usa un campo discriminador (p. ej. type o status) para que el compilador haga narrowing automáticamente.

type Loading = { status: 'loading' };
type Success = { status: 'success'; data: User[] };
type Error = { status: 'error'; reason: string };
type State = Loading | Success | Error;

Esto reduce validaciones en run-time y hace tus reducers/imputs mucho más robustos.

2. Tipos condicionales — lógica de tipos en tiempo de compilación

T extends U ? X : Y te permite transformar tipos según reglas. Úsalos para utilidades genéricas y para adaptar APIs según el input.

type UnwrapPromise = T extends Promise ? R : T;

Evita sobrecomplicar: cuando un tipo condicional se vuelve ilegible, documenta.

3. infer — extrae tipos de dentro de otros tipos

Dentro de los condicionales, infer captura tipos internos (retorno de función, elemento de array).

type ReturnTypeSafe = T extends (...args: any[]) => infer R ? R : never;

Perfecto para tipar automáticamente el retorno de helpers sin repetir firmas.

4. Template literal types — tipos basados en strings

Genera tipos dinámicos para eventos, rutas o claves.

type Method = 'get' | 'post';
type Event = `${Method}:${T}`;

Regala seguridad a APIs que antes dependían de strings mágicos.

5. satisfies — validar sin perder literales

as const y satisfies preservan la inferencia literal mientras validan contra una interfaz.

type Palette = Record<string, string | number>;
const colors = { blue: '#00f' } satisfies Palette;

Úsalo en configs y módulos exportables: valida sin sacrificar precisión.

6. Mapped types y key remapping — transforma tipos a gran escala

Crea getters, mutadores o versiones parciales automáticamente.

type Getters = { [K in keyof T as `get${Capitalize}`]: () => T[K] };

Ideal para generar APIs repetibles (stores, servicios) sin duplicar código.

7. Type Guards y Type Predicates — confianza en runtime

Funciones que retornan arg is Type le dicen al compilador qué acabas de comprobar.

function isError(x: unknown): x is Error { return x instanceof Error; }

Siempre que hagas parsing externo (API, agent output), escribe guards claros.

8. Tipos recursivos — modela árboles y JSON complejos

TypeScript soporta estructuras auto-referenciadas para JSON, ASTs y configs anidadas.

type Json = string | number | boolean | null | Json[] | { [k: string]: Json };

Úsalos donde los datos sean arbitrarios pero predecibles.

9. Awaited — desenreda promesas

Awaited desenvuelve Promise<Promise> de forma segura. Es vital en código async complejo.

type Data = Awaited<ReturnType>;

Sencillo, pero salva horas de inferencia fallida en pipelines asíncronos.

10. Branding (tipos opacos) — nominalidad en un lenguaje estructural

Para distinguir UserId de PostId aunque ambos sean strings:

type Brand<K, T> = K & { __brand: T };
type UserId = Brand<string, 'UserId'>;

Evita mezclar identificadores y reduce errores lógicos críticos.

Automatización real exige tipado real. Cuando construyes agentes, n8n nodes o integraciones que procesan JSON de terceros, estos conceptos no son opcionales: son la base. En Dominicode Labs aplicamos estas técnicas para crear nodos personalizados en n8n y esquemas de validación para agentes LLM, reduciendo fallos por inputs inesperados y acelerando despliegues seguros.

FAQ

• ¿Qué son los Discriminated Unions?
• ¿Para qué sirven los tipos condicionales?
• ¿Qué es infer y cómo se utiliza?
• ¿Cómo se usan los Template literal types?
• ¿Qué es satisfies y por qué es útil?

¿Qué son los Discriminated Unions?

Los Discriminated Unions son un patrón en TypeScript que permite modelar estados usando un campo discriminador, facilitando la reducción de validaciones en tiempo de ejecución al hacer control de los tipos a nivel de compilación.

¿Para qué sirven los tipos condicionales?

Los tipos condicionales permiten evaluar y transformar tipos basados en condiciones, lo cual es útil para crear utilidades genéricas y adaptar el comportamiento de APIs.

¿Qué es infer y cómo se utiliza?

Infer es una palabra clave que permite capturar tipos internos de otros tipos dentro de los tipos condicionales, facilitando la inferencia y reducción de redundancia en la tipificación.

¿Cómo se usan los Template literal types?

Los Template literal types se utilizan para crear tipos dinámicos en TypeScript basándose en combinaciones de strings, garantizando mayor seguridad y evitando errores relacionados con el uso de strings directos.

¿Qué es satisfies y por qué es útil?

Satisfies es un mecanismo de TypeScript que permite validar un objeto contra una interfaz sin perder la inferencia literal, lo cual es especialmente útil en configuraciones y módulos exportables.