Resumen

El patrón Decorator envuelve un objeto dentro de otro que implementa la misma interfaz, añadiendo comportamiento en capas. A diferencia de la herencia, la decoración ocurre en tiempo de ejecución y se puede combinar libremente: el mismo servicio base puede envolverse con un logger, luego con un caché y luego con un retry, en cualquier orden. Es la base de cosas como los middlewares de Express y los higher-order components de React.

Cuándo usarlo

• Necesitas añadir preocupaciones transversales (logging, caché, auth, retry) sin modificar la clase envuelta.
• El conjunto de características que quieres combinar es abierto y varía por punto de uso.
• Subclasificar generaría una explosión combinatoria de clases (LoggedCachedRetryingService...).

Ejemplo

interface DataService {
  fetch(id: string): Promise<string>;
}

class HttpDataService implements DataService {
  async fetch(id: string) { return `data:${id}`; }
}

class LoggingDecorator implements DataService {
  constructor(private readonly inner: DataService) {}
  async fetch(id: string) {
    console.log(`fetch start ${id}`);
    const result = await this.inner.fetch(id);
    console.log(`fetch end ${id}`);
    return result;
  }
}

class CachingDecorator implements DataService {
  private cache = new Map<string, string>();
  constructor(private readonly inner: DataService) {}
  async fetch(id: string) {
    const cached = this.cache.get(id);
    if (cached) return cached;
    const result = await this.inner.fetch(id);
    this.cache.set(id, result);
    return result;
  }
}

const service = new LoggingDecorator(
  new CachingDecorator(new HttpDataService())
);