RxJS Modernize

Operator decision table (pick by intent, not habit)

Recipe 1 — flatten nested subscribes

Before:

this.a$.subscribe(a => {
  this.b(a).subscribe(b => {
    this.c(b).subscribe(c => this.state = c);
  });
});

After:

this.a$.pipe(
  switchMap(a => this.b(a)),
  switchMap(b => this.c(b)),
).subscribe(c => this.state = c);

Pick the operator per row above per level — don't default every level to switchMap without checking whether cancellation is actually correct there.

Recipe 2 — subscription leaks

Before (manual unsubscribe array, easy to forget a push):

this.subs.push(this.data$.subscribe(d => this.items = d));
// ngOnDestroy: this.subs.forEach(s => s.unsubscribe());

After (preferred — template):

<div *ngFor="let item of items$ | async; trackBy: trackById">

After (when async pipe isn't viable — imperative subscription needed):

this.data$.pipe(takeUntilDestroyed()).subscribe(d => this.items = d);

Async pipe is the default; takeUntilDestroyed() is the fallback for subscriptions that must live in a service or component method body.

Recipe 3 — logic in subscribe callbacks

Before:

this.data$.subscribe(d => {
  const filtered = d.filter(x => x.active);
  this.items = filtered.map(x => x.name);
});

After — move transforms into the pipe, subscribe only assigns:

this.items$ = this.data$.pipe(
  map(d => d.filter(x => x.active).map(x => x.name)),
);

Procedure

1. Identify every anti-pattern instance in the target file(s) before touching any of them (list file:line per instance).
2. Apply one recipe at a time. Run tests after each individual change — don't batch multiple flattening changes into one untested edit.
3. If no tests exist for the file being modernized, stop and route to characterization-tests first — Rx timing changes are exactly the kind of change that needs a behavior pin beforehand.
4. Report before/after per instance and the test result after each.

Anti-patterns

• Never default to switchMap for writes — cancelling an in-flight save silently drops data.
• Never leave a mergeMap without a comment justifying unordered concurrency is safe.
• Never batch multiple recipe applications into one commit without an intermediate green test run.