TypeScript Utility Types que debes conocer

TypeScript incluye varios utility types integrados que te ayudan a transformar tipos de maneras comunes. Veamos los más útiles.

Partial

Hace todas las propiedades opcionales:

interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

function updateUser(id: number, updates: Partial<User>) {
  // Puedes pasar solo las propiedades que quieres actualizar
}

updateUser(1, { name: "Roberto" }); // ✓ OK
updateUser(2, { email: "nuevo@email.com", age: 30 }); // ✓ OK

Required

Lo opuesto a Partial, hace todas las propiedades requeridas:

interface Config {
  host?: string;
  port?: number;
  ssl?: boolean;
}

function connect(config: Required<Config>) {
  // Ahora todas las propiedades son obligatorias
}

// connect({ host: "localhost" }); // ✗ Error
connect({ host: "localhost", port: 3000, ssl: true }); // ✓ OK

Pick<T, K>

Crea un tipo seleccionando propiedades específicas:

interface Article {
  id: number;
  title: string;
  content: string;
  author: string;
  createdAt: Date;
  updatedAt: Date;
}

type ArticlePreview = Pick<Article, 'id' | 'title' | 'author'>;

const preview: ArticlePreview = {
  id: 1,
  title: "Mi artículo",
  author: "Roberto"
  // No necesita content, createdAt, updatedAt
};

Omit<T, K>

Lo opuesto a Pick, excluye propiedades:

type ArticleCreate = Omit<Article, 'id' | 'createdAt' | 'updatedAt'>;

const newArticle: ArticleCreate = {
  title: "Nuevo artículo",
  content: "Contenido...",
  author: "Roberto"
  // No incluye id, createdAt, updatedAt
};

Record<K, T>

Crea un tipo de objeto con claves específicas:

type Role = 'admin' | 'user' | 'guest';

const permissions: Record<Role, string[]> = {
  admin: ['read', 'write', 'delete'],
  user: ['read', 'write'],
  guest: ['read']
};

// Traducciones
type Language = 'es' | 'en' | 'fr';
const greetings: Record<Language, string> = {
  es: "Hola",
  en: "Hello",
  fr: "Bonjour"
};

Readonly

Hace todas las propiedades de solo lectura:

interface Point {
  x: number;
  y: number;
}

const point: Readonly<Point> = { x: 10, y: 20 };
// point.x = 5; // ✗ Error: Cannot assign to 'x'

ReturnType

Obtiene el tipo de retorno de una función:

function createUser() {
  return {
    id: 1,
    name: "Roberto",
    email: "roberto@example.com"
  };
}

type User = ReturnType<typeof createUser>;
// User es { id: number; name: string; email: string; }

Parameters

Obtiene los tipos de los parámetros de una función:

function login(username: string, password: string, remember: boolean) {
  // ...
}

type LoginParams = Parameters<typeof login>;
// LoginParams es [string, string, boolean]

function wrapper(...args: LoginParams) {
  login(...args);
}

Exclude<T, U>

Excluye tipos de una unión:

type AllRoles = 'admin' | 'user' | 'guest' | 'superadmin';
type RegularRoles = Exclude<AllRoles, 'superadmin'>;
// RegularRoles es 'admin' | 'user' | 'guest'

NonNullable

Excluye null y undefined:

type MaybeString = string | null | undefined;
type DefiniteString = NonNullable<MaybeString>;
// DefiniteString es string

Combinando Utility Types

interface ApiResponse<T> {
  data: T;
  status: number;
  error?: string;
}

type SuccessResponse<T> = Required<Omit<ApiResponse<T>, 'error'>>;
type ErrorResponse = Required<Pick<ApiResponse<null>, 'status' | 'error'>>;

Conclusión

Los utility types de TypeScript son herramientas poderosas que te permiten manipular tipos de manera declarativa, haciendo tu código más type-safe y mantenible.