Spaces:
Build error
Build error
File size: 4,179 Bytes
c211499 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 |
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsyncCaller = void 0;
const p_retry_1 = __importDefault(require("p-retry"));
const p_queue_1 = __importDefault(require("p-queue"));
const STATUS_NO_RETRY = [
400,
401,
403,
404,
405,
406,
407,
408,
409, // Conflict
];
/**
* A class that can be used to make async calls with concurrency and retry logic.
*
* This is useful for making calls to any kind of "expensive" external resource,
* be it because it's rate-limited, subject to network issues, etc.
*
* Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
* to `Infinity`. This means that by default, all calls will be made in parallel.
*
* Retries are limited by the `maxRetries` parameter, which defaults to 6. This
* means that by default, each call will be retried up to 6 times, with an
* exponential backoff between each attempt.
*/
class AsyncCaller {
constructor(params) {
Object.defineProperty(this, "maxConcurrency", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "maxRetries", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "queue", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.maxConcurrency = params.maxConcurrency ?? Infinity;
this.maxRetries = params.maxRetries ?? 6;
const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
this.queue = new PQueue({ concurrency: this.maxConcurrency });
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
call(callable, ...args) {
return this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch((error) => {
// eslint-disable-next-line no-instanceof/no-instanceof
if (error instanceof Error) {
throw error;
}
else {
throw new Error(error);
}
}), {
onFailedAttempt(error) {
if (error.message.startsWith("Cancel") ||
error.message.startsWith("TimeoutError") ||
error.message.startsWith("AbortError")) {
throw error;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
if (error?.code === "ECONNABORTED") {
throw error;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const status = error?.response?.status;
if (status && STATUS_NO_RETRY.includes(+status)) {
throw error;
}
},
retries: this.maxRetries,
randomize: true,
// If needed we can change some of the defaults here,
// but they're quite sensible.
}), { throwOnTimeout: true });
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
callWithOptions(options, callable, ...args) {
// Note this doesn't cancel the underlying request,
// when available prefer to use the signal option of the underlying call
if (options.signal) {
return Promise.race([
this.call(callable, ...args),
new Promise((_, reject) => {
options.signal?.addEventListener("abort", () => {
reject(new Error("AbortError"));
});
}),
]);
}
return this.call(callable, ...args);
}
fetch(...args) {
return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res))));
}
}
exports.AsyncCaller = AsyncCaller;
|