Cómo simplificar suscripciones asíncronas anidadas en Angular: Un ejemplo práctico

// ⚠️ ANTIPATRÓN: Suscripciones anidadas en TypeScript
export class UserDashboardComponent implements OnInit {
  user: User | null = null;
  permissions: Permission[] = [];
  subscription: SubscriptionPlan | null = null;
 
  constructor(
    private authService: AuthService,
    private permissionService: PermissionService,
    private billingService: BillingService
  ) {}
 
  ngOnInit(): void {
    // 😫 Callback Hell: difícil de desuscribirse, imposible de cancelar, manejo de errores frágil.
    this.authService.getCurrentUser().subscribe((user) => {
      this.user = user;
      
      this.permissionService.getPermissions(user.id).subscribe((perms) => {
        this.permissions = perms;
 
        this.billingService.getPlan(user.tenantId).subscribe((plan) => {
          this.subscription = plan;
        });
      });
    });
  }
}

// user-dashboard.component.ts (Composición con RxJS)
import { Component, inject } from '@angular/core';
import { Observable, switchMap, forkJoin } from 'rxjs';
import { AuthService, PermissionService, BillingService, User, Permission, SubscriptionPlan } from '../services';
 
interface DashboardState {
  user: User;
  permissions: Permission[];
  plan: SubscriptionPlan;
}
 
@Component({
  selector: 'app-user-dashboard',
  templateUrl: './user-dashboard.component.html',
})
export class UserDashboardComponent {
  private authService = inject(AuthService);
  private permissionService = inject(PermissionService);
  private billingService = inject(BillingService);
 
  // Un único flujo consolidado para la vista
  readonly state$: Observable<DashboardState> = this.authService.getCurrentUser().pipe(
    switchMap((user) =>
      // Ejecutar llamadas en paralelo una vez resuelto el usuario
      forkJoin({
        user: of(user),
        permissions: this.permissionService.getPermissions(user.id),
        plan: this.billingService.getPlan(user.tenantId),
      })
    )
  );
}

<!-- Desempaquetado de ViewModel clásico en la plantilla -->
<ng-container *ngIf="state$ | async as state">
  <div class="user-card">
    <h2>Welcome, {{ state.user.name }}</h2>
    <p>Plan: {{ state.plan.name }}</p>
 
    <ul>
      <li *ngFor="let perm of state.permissions">{{ perm.name }}</li>
    </ul>
  </div>
</ng-container>

// user-dashboard.component.ts (Standalone y Signals modernos)
import { Component, inject } from '@angular/core';
import { toSignal } from '@angular/core/rxjs-interop';
import { switchMap, forkJoin, of } from 'rxjs';
import { AuthService, PermissionService, BillingService } from '../services';
 
@Component({
  selector: 'app-user-dashboard',
  standalone: true,
  templateUrl: './user-dashboard.component.html',
})
export class UserDashboardComponent {
  private authService = inject(AuthService);
  private permissionService = inject(PermissionService);
  private billingService = inject(BillingService);
 
  private state$ = this.authService.getCurrentUser().pipe(
    switchMap((user) =>
      forkJoin({
        user: of(user),
        permissions: this.permissionService.getPermissions(user.id),
        plan: this.billingService.getPlan(user.tenantId),
      })
    )
  );
 
  // Exponer como un Signal síncrono gestionado automáticamente
  state = toSignal(this.state$);
}

<!-- user-dashboard.component.html (Control de flujo moderno y @let) -->
@if (state(); as data) {
  <div class="user-card">
    <h2>Welcome, {{ data.user.name }}</h2>
    <span class="badge">{{ data.plan.name }}</span>
 
    <ul class="permissions-list">
      @for (perm of data.permissions; track perm.id) {
        <li>{{ perm.name }}</li>
      } @empty {
        <li>No special permissions assigned.</li>
      }
    </ul>
  </div>
} @else {
  <div class="skeleton-loader">Loading user details...</div>
}