87 lines
2.1 KiB
TypeScript
87 lines
2.1 KiB
TypeScript
const retryKinds: ReadonlySet<string> = new Set([
|
|
"NETWORK_UNREACHABLE",
|
|
"REQUEST_TIMEOUT",
|
|
"RATE_LIMITED",
|
|
"SERVER_FAILURE",
|
|
]);
|
|
|
|
export function calculateBackoff(
|
|
retryIndex: number,
|
|
random = Math.random,
|
|
baseDelayMs = 250,
|
|
maxDelayMs = 2_000,
|
|
): number {
|
|
return Math.min(maxDelayMs, baseDelayMs * 2 ** retryIndex) * random();
|
|
}
|
|
|
|
export function parseRetryAfter(
|
|
value: string | null | undefined,
|
|
now = Date.now(),
|
|
): number | null {
|
|
if (!value) return null;
|
|
|
|
const seconds = Number(value);
|
|
if (Number.isFinite(seconds)) {
|
|
return seconds < 0 ? null : seconds * 1_000;
|
|
}
|
|
|
|
const timestamp = Date.parse(value);
|
|
if (!Number.isFinite(timestamp)) return null;
|
|
return Math.max(0, timestamp - now);
|
|
}
|
|
|
|
export type RetryOperation = Readonly<{
|
|
idempotency: "safe" | "keyed" | "none";
|
|
retry?: "runtime" | "never";
|
|
}>;
|
|
|
|
export type RetryFailure = Readonly<{
|
|
kind: string;
|
|
retryAfterMs?: number;
|
|
retryAfter?: string;
|
|
httpStatus?: number;
|
|
}>;
|
|
|
|
export function shouldRetry(
|
|
operation: RetryOperation,
|
|
failure: RetryFailure,
|
|
retryCount: number,
|
|
maxRetries = 2,
|
|
): boolean {
|
|
if (operation.retry === "never") return false;
|
|
if (retryCount >= maxRetries) return false;
|
|
if (!retryKinds.has(failure.kind)) return false;
|
|
if (
|
|
failure.kind === "SERVER_FAILURE" &&
|
|
failure.httpStatus !== undefined &&
|
|
![502, 503, 504].includes(failure.httpStatus)
|
|
) {
|
|
return false;
|
|
}
|
|
if (
|
|
failure.kind === "RATE_LIMITED" &&
|
|
typeof failure.retryAfterMs === "number" &&
|
|
failure.retryAfterMs > 30_000
|
|
) {
|
|
return false;
|
|
}
|
|
return operation.idempotency === "safe" || operation.idempotency === "keyed";
|
|
}
|
|
|
|
export function retryDelay(
|
|
failure: RetryFailure,
|
|
retryIndex: number,
|
|
random = Math.random,
|
|
now = Date.now(),
|
|
): number {
|
|
const localBackoff = calculateBackoff(retryIndex, random);
|
|
if (failure.kind !== "RATE_LIMITED") return localBackoff;
|
|
|
|
const retryAfterMs =
|
|
typeof failure.retryAfterMs === "number"
|
|
? failure.retryAfterMs
|
|
: parseRetryAfter(failure.retryAfter, now);
|
|
|
|
return retryAfterMs === null ? localBackoff : Math.max(localBackoff, retryAfterMs);
|
|
}
|