求.NET Polly库的Angular（JavaScript）等效弹性故障处理工具

Great question! I totally get why you're impressed with Polly—it's such a robust, user-friendly tool for handling transient faults in .NET. Let's walk through your options for Angular/JavaScript:

1. Build on RxJS with Custom Wrappers (Leverage What You Already Use) #

Since you're already working with RxJS's retry, timeout, etc., you can wrap these operators into a Polly-esque service that adds caching and combines multiple resilience strategies. Here's a quick example of an Angular service that adds retry, timeout, and in-memory caching to HTTP calls:

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable, of, tap } from 'rxjs';
import { retry, timeout, catchError } from 'rxjs/operators';

@Injectable({ providedIn: 'root' })
export class ResilientHttpService {
  private responseCache = new Map<string, any>();

  constructor(private http: HttpClient) {}

  fetchWithResilience(url: string, cacheKey: string): Observable<any> {
    // Return cached data if available
    if (this.responseCache.has(cacheKey)) {
      return of(this.responseCache.get(cacheKey));
    }

    return this.http.get(url).pipe(
      timeout(5000), // Fail after 5 seconds
      retry(3), // Retry up to 3 times on errors
      tap(response => this.responseCache.set(cacheKey, response)), // Cache successful responses
      catchError(() => of({ fallbackData: 'Fallback content' })) // Fallback on total failure
    );
  }
}

You can expand this further to add more Polly-style features:

• Circuit Breaker: Add a state tracker (e.g., a class property to track failure counts) and use delayWhen to pause requests when the circuit is open.
• Bulkhead Isolation: Use a semaphore-like pattern to limit concurrent requests to a resource.

2. Try Dedicated JavaScript Resilience Libraries #

There are a few JS/TS libraries that mirror Polly's core functionality and play nicely with Angular:

• cockatiel: A lightweight library that supports retry, circuit breakers, timeouts, and bulkhead isolation. It works with Promises, which you can easily convert to Observables using RxJS's from operator.
• p-retry + p-timeout + p-circuit-breaker: These are focused, single-purpose packages that you can combine to replicate Polly's full feature set. Like cockatiel, you can wrap their Promise outputs for use in Angular.

3. Propose a JavaScript Port of Polly #

If none of the existing tools fit your needs, reaching out to the Polly team on their GitHub repo is a solid move! Their community is active, and a TypeScript port would likely be a popular feature request. You could even start a community-driven port yourself—Polly's design is well-documented, so adapting its strategy patterns to JS/TS would be totally feasible.

For immediate use, building custom RxJS wrappers is the fastest way to get Polly-like behavior in your Angular app, while dedicated libraries offer pre-built, battle-tested resilience logic.

内容的提问来源于stack exchange，提问作者peterc