Category: TypeScript

Tiempo estimado de lectura: 4 min

• Ideas clave:
• Usa los Utility Types para derivar tipos desde una única fuente de verdad y evitar duplicación.
• Partial/Required/Readonly transforman la optionalidad e inmutabilidad de propiedades.
• Pick/Omit/Record y las utilidades de unión (Exclude/Extract/NonNullable) refinan shapes sin reescribir interfaces.
• ReturnType y Parameters facilitan mantener firmas coherentes entre capas.

interface Usuario { id: number; nombre: string; email: string; }
type UsuarioPatch = Partial; // { id?: number; nombre?: string; email?: string }

interface Opts { timeout?: number; retries?: number; }
type OptsFull = Required; // timeout y retries obligatorios

type Estado = Readonly<{ id: number; name: string }>;

interface Producto { id: string; nombre: string; precio: number; costo: number; }
type ProductoCard = Pick<Producto, "id" | "nombre" | "precio">;

type ProductoPublico = Omit<Producto, "costo">;

type Rol = "admin" | "user" | "guest";
const permisos: Record<Rol, boolean> = { admin: true, user: true, guest: false };

type Estado = "idle" | "loading" | "success" | "error";
type EstadoFinal = Exclude<Estado, "idle" | "loading">; // "success" | "error"

type Evento = string | number | (() => void);
type Callbacks = Extract<Evento, Function>; // () => void

type Res = string | null | undefined;
type ResNoNull = NonNullable<Res>; // string

function crearConfig() { return { host: "db", port: 5432 }; }
type Config = ReturnType<typeof crearConfig>; // { host: string; port: number }

function emitir(event: string, payload: unknown, priority = 0) {}
type EmitArgs = Parameters<typeof emitir>; // [string, unknown, number?]

interface UserEntity { id: string; name: string; passwordHash: string; email: string; }
type UserPublic = Omit<UserEntity, "passwordHash">;

function normalize(cfg: Partial<Conf>): Required<Conf> {
  return { timeout: cfg.timeout ?? 5000, retries: cfg.retries ?? 3 };
}

type FetchUsers = () => Promise<User[]>;
type Users = ReturnType<FetchUsers> extends Promise<infer U> ? U : never;
const byId: Record<string, Users[0]> = {};

FAQ

• ¿Qué es un Utility Type en TypeScript?
• ¿Cuándo debo usar Partial?
• ¿Cuál es la diferencia entre Pick y Omit?
• ¿Para qué sirve Record?
• ¿Cómo ayudo ReturnType en arquitecturas en capas?
• ¿Qué cuidados tener con Partial y validación?

¿Qué es un Utility Type en TypeScript?

Un Utility Type es un tipo provisto por TypeScript que transforma tipos existentes sin reescribirlos, por ejemplo Partial, Pick, ReturnType. Se usan para derivar nuevos shapes a partir de una fuente de verdad.

¿Cuándo debo usar Partial?

Usa Partial para inputs opcionales como formularios de edición o endpoints PATCH donde no todos los campos son obligatorios. Evita abusar de Partial cuando la ausencia de campos puede ocultar requisitos críticos.

¿Cuál es la diferencia entre Pick y Omit?

Pick crea un subtipo seleccionando propiedades concretas; Omit crea un subtipo excluyendo propiedades. Usa Pick cuando quieres unas pocas propiedades y Omit para el tipo completo menos algunas.

¿Para qué sirve Record?

Record tipa objetos clave-valor con claves de un union literal conocido. Es útil para mapas indexados por roles o IDs cuando las claves son previsibles. Para claves dinámicas complejas considera Map o validación extra.

¿Cómo ayuda ReturnType en arquitecturas en capas?

ReturnType infiere automáticamente el tipo de retorno de una función, reduciendo duplicación de tipos entre capas (por ejemplo, fetchers y mappers). Se combina con condicionales (infer) para desestructurar tipos asíncronos.

¿Qué cuidados tener con Partial y validación?

Precaución: Partial puede ocultar requisitos importantes. Cuando la validez de los datos importa en runtime, aplica validación explícita y transforma Partial en un tipo requerido tras aplicar defaults o comprobaciones.

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.