Class RetryHttpLibrary

sdks/typescript/src/v1/retry.ts:54–235

}

export class RetryHttpLibrary implements HttpLibrary {
  constructor(
    private readonly inner: HttpLibrary,
    private readonly opts: RetryOptions = {},
  ) {}

  send(request: RequestContext): Observable<ResponseContext> {
    return from(this.sendWithRetry(request));
  }

  private async sendWithRetry(request: RequestContext): Promise<ResponseContext> {
    // Decide retry-safety BEFORE mutating headers — it depends on whether the
    // generated layer already emitted an Idempotency-Key stub (server-deduped
    // POSTs) which ensureIdempotencyKey would otherwise fill in and obscure.
    const retrySafe = this.isRetrySafe(request);
    if (retrySafe) this.ensureIdempotencyKey(request);
    const max = this.opts.maxRetries ?? 2;
    const now = this.opts.now ?? Date.now;
    const start = now();
    const signal = request.getSignal?.();

    let attempt = 0;
    for (;;) {
      this.throwIfAborted(signal);

      let resp: ResponseContext | undefined;
      let connErr: unknown;
      try {
        resp = await this.inner.send(request).toPromise();
      } catch (e) {
        connErr = e; // connection-level failure (no HTTP response)
      }

      const isConn = resp === undefined;
      const retryable = retrySafe && (isConn || isRetryableStatus(resp!.httpStatusCode));
      if (!retryable || attempt >= max) {
        if (resp !== undefined) return resp;
        throw connErr;
      }

      const delay = this.backoffMs(attempt, resp);
      // Total-deadline guard: don't start a wait that would blow the deadline.
      if (this.opts.maxElapsedMs !== undefined && now() - start + delay > this.opts.maxElapsedMs) {
        if (resp !== undefined) return resp;
        throw connErr;
      }
      await this.sleep(delay, signal);
      attempt += 1;
    }
  }

  // Whether this request may be safely re-sent after a transient failure.
  //
  // Retrying a non-idempotent POST after an ambiguous failure can double-create
  // a resource: the server commits the write, then the connection drops or a 5xx
  // is returned, and a blind retry creates a SECOND row. So we only retry:
  //   - reads (GET/HEAD/OPTIONS) — no side effects;
  //   - HTTP-idempotent writes (PUT/PATCH/DELETE) — repeating reaches the same