This commit is contained in:
2026-08-14 16:03:47 +01:00
parent fd53e3f4fb
commit dfdc3b2840
2463 changed files with 186456 additions and 111315 deletions
+1
View File
@@ -1,3 +1,4 @@
Copyright (c) 2011 Tim Koschützki (tim@debuggable.com), Felix Geisendörfer (felix@debuggable.com)
Copyright (c) 2014 IndigoUnited
Permission is hereby granted, free of charge, to any person obtaining a copy
+9 -3
View File
@@ -1,6 +1,7 @@
# @gar/promise-retry
This is a fork of [promise-retry](https://npm.im/promise-retry) to keep its dependencies current. See the [CHANGELOG.md](./CHANGELOG.md) for more info.
This is a fork of [promise-retry](https://npm.im/promise-retry). See the [CHANGELOG.md](./CHANGELOG.md) for more info.
It also inlines and updates the original [retry](https://github.com/tim-kos/node-retry) package that was being promisified.
Retries a function that returns a promise, leveraging the power of the [retry](https://github.com/tim-kos/node-retry) module to the promises world.
@@ -17,19 +18,24 @@ There's already some modules that are able to retry functions that return promis
### retry(fn(retry, number, operation), [options])
Calls `fn` until the returned promise ends up fulfilled or rejected with an error different than a `retry` error.
The `options` argument is an object which maps to the [retry](https://github.com/tim-kos/node-retry) module options:
The `options` argument is an object which maps to the original [retry](https://github.com/tim-kos/node-retry) module options:
- `retries`: The maximum amount of times to retry the operation. Default is `10`.
- `factor`: The exponential factor to use. Default is `2`.
- `minTimeout`: The number of milliseconds before starting the first retry. Default is `1000`.
- `maxTimeout`: The maximum number of milliseconds between two retries. Default is `Infinity`.
- `randomize`: Randomizes the timeouts by multiplying with a factor between `1` to `2`. Default is `false`.
- `forever`: Whether to retry forver, default is false.
- `unref`: Whether to [unref](https://nodejs.org/api/timers.html#timers_unref) the underlying `setTimeout`s.
- `maxRetryTime`: Maximum number of milliseconds that the retried operation is allowed to run.
`options` can also be a Number, which is effectively the same as pasing `{ retries: Number }`
The `fn` function will be called with the following parameters:
- A `retry` function as its first argument that should be called with an error whenever you want to retry `fn`. The `retry` function will always throw an error.
- The current retry number being attempted
- The operation object itself from [retry](https://github.com/tim-kos/node-retry) which will allow you to call things like `operation.reset()`
- The retry operation object itself from which will allow you to call things like `operation.reset()`
If there are retries left, it will throw a special `retry` error that will be handled internally to call `fn` again.
If there are no retries left, it will throw the actual error passed to it.
+2 -16
View File
@@ -41,17 +41,6 @@ type OperationOptions = {
maxRetryTime?: number | undefined;
} | number[];
type AttemptTimeoutOptions = {
/**
* A timeout in milliseconds.
*/
timeout?: number | undefined;
/**
* Callback to execute when the operation takes longer than the timeout.
*/
callback?(): void;
}
type RetryOperation = {
/**
* Returns an array of all errors that have been passed to `retryOperation.retry()` so far.
@@ -72,12 +61,9 @@ type RetryOperation = {
/**
* Defines the function that is to be retried and executes it for the first time right away.
*
* @param fn The function that is to be retried. `currentAttempt` represents the number of attempts
* callback has been executed so far.
* @param [timeoutOps.timeout] A timeout in milliseconds.
* @param [timeoutOps.callback] Callback to execute when the operation takes longer than the timeout.
* @param fn The function that is to be retried. `currentAttempt` represents the number of attempts callback has been executed so far.
*/
attempt(fn: (currentAttempt: number) => void, timeoutOps?: AttemptTimeoutOptions): void;
attempt(fn: (currentAttempt: number) => void): void;
/**
* Returns `false` when no `error` value is given, or the maximum amount of retries has been reached.
+43 -9
View File
@@ -1,9 +1,44 @@
const retry = require('retry')
const { RetryOperation } = require('./retry')
const isRetryError = (err) => err?.code === 'EPROMISERETRY' && Object.hasOwn(err, 'retried')
const createTimeout = (attempt, opts) => Math.min(Math.round((1 + (opts.randomize ? Math.random() : 0)) * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt)), opts.maxTimeout)
const isRetryError = err => err?.code === 'EPROMISERETRY' && Object.hasOwn(err, 'retried')
async function promiseRetry (fn, options = {}) {
const operation = retry.operation(options)
const promiseRetry = async (fn, options = {}) => {
let timeouts = []
if (options instanceof Array) {
timeouts = [...options]
} else {
if (options.retries === Infinity) {
options.forever = true
delete options.retries
}
const opts = {
retries: 10,
factor: 2,
minTimeout: 1 * 1000,
maxTimeout: Infinity,
randomize: false,
...options
}
if (opts.minTimeout > opts.maxTimeout) {
throw new Error('minTimeout is greater than maxTimeout')
}
if (opts.retries) {
for (let i = 0; i < opts.retries; i++) {
timeouts.push(createTimeout(i, opts))
}
// sort the array numerically ascending (since the timeouts may be out of order at factor < 1)
timeouts.sort((a, b) => a - b)
} else if (options.forever) {
timeouts.push(createTimeout(0, opts))
}
}
const operation = new RetryOperation(timeouts, {
forever: options.forever,
unref: options.unref,
maxRetryTime: options.maxRetryTime
})
return new Promise(function (resolve, reject) {
operation.attempt(async number => {
@@ -13,13 +48,12 @@ async function promiseRetry (fn, options = {}) {
}, number, operation)
return resolve(result)
} catch (err) {
if (isRetryError(err)) {
if (operation.retry(err.retried || new Error())) {
return
}
if (!isRetryError(err)) {
return reject(err)
}
if (!operation.retry(err.retried || new Error())) {
return reject(err.retried)
}
return reject(err)
}
})
})
+109
View File
@@ -0,0 +1,109 @@
class RetryOperation {
#attempts = 1
#cachedTimeouts = null
#errors = []
#fn = null
#maxRetryTime
#operationStart = null
#originalTimeouts
#timeouts
#timer = null
#unref
constructor (timeouts, options = {}) {
this.#originalTimeouts = [...timeouts]
this.#timeouts = [...timeouts]
this.#unref = options.unref
this.#maxRetryTime = options.maxRetryTime || Infinity
if (options.forever) {
this.#cachedTimeouts = [...this.#timeouts]
}
}
get timeouts () {
return [...this.#timeouts]
}
get errors () {
return [...this.#errors]
}
get attempts () {
return this.#attempts
}
get mainError () {
let mainError = null
if (this.#errors.length) {
let mainErrorCount = 0
const counts = {}
for (let i = 0; i < this.#errors.length; i++) {
const error = this.#errors[i]
const { message } = error
if (!counts[message]) {
counts[message] = 0
}
counts[message]++
if (counts[message] >= mainErrorCount) {
mainError = error
mainErrorCount = counts[message]
}
}
}
return mainError
}
reset () {
this.#attempts = 1
this.#timeouts = [...this.#originalTimeouts]
}
stop () {
if (this.#timer) {
clearTimeout(this.#timer)
}
this.#timeouts = []
this.#cachedTimeouts = null
}
retry (err) {
this.#errors.push(err)
if (new Date().getTime() - this.#operationStart >= this.#maxRetryTime) {
// XXX This puts the timeout error first, meaning it will never show as mainError, there may be no way to ever see this
this.#errors.unshift(new Error('RetryOperation timeout occurred'))
return false
}
let timeout = this.#timeouts.shift()
if (timeout === undefined) {
// We're out of timeouts, clear the last error and repeat the final timeout
if (this.#cachedTimeouts) {
this.#errors.pop()
timeout = this.#cachedTimeouts.at(-1)
} else {
return false
}
}
// TODO what if there already is a timer?
this.#timer = setTimeout(() => {
this.#attempts++
this.#fn(this.#attempts)
}, timeout)
if (this.#unref) {
this.#timer.unref()
}
return true
}
attempt (fn) {
this.#fn = fn
this.#operationStart = new Date().getTime()
this.#fn(this.#attempts)
}
}
module.exports = { RetryOperation }
+1 -4
View File
@@ -1,6 +1,6 @@
{
"name": "@gar/promise-retry",
"version": "1.0.2",
"version": "1.0.3",
"description": "Retries a function that returns a promise, leveraging the power of the retry module.",
"main": "./lib/index.js",
"files": [
@@ -39,9 +39,6 @@
"replay"
],
"license": "MIT",
"dependencies": {
"retry": "^0.13.1"
},
"engines": {
"node": "^20.17.0 || >=22.9.0"
}