Primeiro commit do projeto Angular
This commit is contained in:
+19
@@ -0,0 +1,19 @@
|
||||
Copyright (c) 2014 IndigoUnited
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is furnished
|
||||
to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
# @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.
|
||||
|
||||
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.
|
||||
|
||||
There's already some modules that are able to retry functions that return promises but they were rather difficult to use or do not offer an easy way to do conditional retries.
|
||||
|
||||
|
||||
## Installation
|
||||
|
||||
`$ npm install promise-retry`
|
||||
|
||||
|
||||
## Usage
|
||||
|
||||
### 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:
|
||||
|
||||
- `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`.
|
||||
|
||||
|
||||
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()`
|
||||
|
||||
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.
|
||||
|
||||
## Example
|
||||
```js
|
||||
const { retry } = require('@gar/promise-retry');
|
||||
|
||||
// Simple example
|
||||
retry(function (retry, number) {
|
||||
console.log('attempt number', number);
|
||||
|
||||
return doSomething()
|
||||
.catch(retry);
|
||||
})
|
||||
.then(function (value) {
|
||||
// ..
|
||||
}, function (err) {
|
||||
// ..
|
||||
});
|
||||
|
||||
// Conditional example
|
||||
retry(function (retry, number) {
|
||||
console.log('attempt number', number);
|
||||
|
||||
return doSomething()
|
||||
.catch(function (err) {
|
||||
if (err.code === 'ETIMEDOUT') {
|
||||
retry(err);
|
||||
}
|
||||
|
||||
throw err;
|
||||
});
|
||||
})
|
||||
.then(function (value) {
|
||||
// ..
|
||||
}, function (err) {
|
||||
// ..
|
||||
});
|
||||
```
|
||||
|
||||
## Tests
|
||||
|
||||
`$ npm test`
|
||||
|
||||
## License
|
||||
|
||||
Released under the [MIT License](http://www.opensource.org/licenses/mit-license.php).
|
||||
+128
@@ -0,0 +1,128 @@
|
||||
type OperationOptions = {
|
||||
/**
|
||||
* The exponential factor to use.
|
||||
* @default 2
|
||||
*/
|
||||
factor?: number | undefined;
|
||||
/**
|
||||
* The number of milliseconds before starting the first retry.
|
||||
* @default 1000
|
||||
*/
|
||||
minTimeout?: number | undefined;
|
||||
/**
|
||||
* The maximum number of milliseconds between two retries.
|
||||
* @default Infinity
|
||||
*/
|
||||
maxTimeout?: number | undefined;
|
||||
/**
|
||||
* Randomizes the timeouts by multiplying a factor between 1-2.
|
||||
* @default false
|
||||
*/
|
||||
randomize?: boolean | undefined;
|
||||
/**
|
||||
* The maximum amount of times to retry the operation.
|
||||
* @default 10
|
||||
*/
|
||||
retries?: number | undefined;
|
||||
/**
|
||||
* Whether to retry forever.
|
||||
* @default false
|
||||
*/
|
||||
forever?: boolean | undefined;
|
||||
/**
|
||||
* Whether to [unref](https://nodejs.org/api/timers.html#timers_unref) the setTimeout's.
|
||||
* @default false
|
||||
*/
|
||||
unref?: boolean | undefined;
|
||||
/**
|
||||
* The maximum time (in milliseconds) that the retried operation is allowed to run.
|
||||
* @default Infinity
|
||||
*/
|
||||
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.
|
||||
* The returning array has the errors ordered chronologically based on when they were passed to
|
||||
* `retryOperation.retry()`, which means the first passed error is at index zero and the last is at the last index.
|
||||
*/
|
||||
errors(): Error[];
|
||||
|
||||
/**
|
||||
* A reference to the error object that occured most frequently.
|
||||
* Errors are compared using the `error.message` property.
|
||||
* If multiple error messages occured the same amount of time, the last error object with that message is returned.
|
||||
*
|
||||
* @return If no errors occured so far the value will be `null`.
|
||||
*/
|
||||
mainError(): Error | null;
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
attempt(fn: (currentAttempt: number) => void, timeoutOps?: AttemptTimeoutOptions): void;
|
||||
|
||||
/**
|
||||
* Returns `false` when no `error` value is given, or the maximum amount of retries has been reached.
|
||||
* Otherwise it returns `true`, and retries the operation after the timeout for the current attempt number.
|
||||
*/
|
||||
retry(err?: Error): boolean;
|
||||
|
||||
/**
|
||||
* Stops the operation being retried. Useful for aborting the operation on a fatal error etc.
|
||||
*/
|
||||
stop(): void;
|
||||
|
||||
/**
|
||||
* Resets the internal state of the operation object, so that you can call `attempt()` again as if
|
||||
* this was a new operation object.
|
||||
*/
|
||||
reset(): void;
|
||||
|
||||
/**
|
||||
* Returns an int representing the number of attempts it took to call `fn` before it was successful.
|
||||
*/
|
||||
attempts(): number;
|
||||
}
|
||||
|
||||
/**
|
||||
* A function that is retryable, by having implicitly-bound params for both an error handler and an attempt number.
|
||||
*
|
||||
* @param retry The retry callback upon any rejection. Essentially throws the error on in the form of a { retried: err }
|
||||
* wrapper, and tags it with a 'code' field of value "EPROMISERETRY" so that it is recognised as needing retrying. Call
|
||||
* this from the catch() block when you want to retry a rejected attempt.
|
||||
* @param attempt The number of the attempt.
|
||||
* @param operation The operation object from the underlying retry module.
|
||||
* @returns A Promise for anything (eg. a HTTP response).
|
||||
*/
|
||||
type RetryableFn<ResolutionType> = (retry: (error: any) => never, attempt: number, operation: RetryOperation) => Promise<ResolutionType>;
|
||||
/**
|
||||
* Wrap all functions of the object with retry. The params can be entered in either order, just like in the original library.
|
||||
*
|
||||
* @param retryableFn The function to retry.
|
||||
* @param options The options for how long/often to retry the function for.
|
||||
* @returns The Promise resolved by the input retryableFn, or rejected (if not retried) from its catch block.
|
||||
*/
|
||||
declare function promiseRetry<ResolutionType>(
|
||||
retryableFn: RetryableFn<ResolutionType>,
|
||||
options?: OperationOptions,
|
||||
): Promise<ResolutionType>;
|
||||
|
||||
export { promiseRetry };
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
const retry = require('retry')
|
||||
|
||||
const isRetryError = (err) => err?.code === 'EPROMISERETRY' && Object.hasOwn(err, 'retried')
|
||||
|
||||
async function promiseRetry (fn, options = {}) {
|
||||
const operation = retry.operation(options)
|
||||
|
||||
return new Promise(function (resolve, reject) {
|
||||
operation.attempt(async number => {
|
||||
try {
|
||||
const result = await fn(err => {
|
||||
throw Object.assign(new Error('Retrying'), { code: 'EPROMISERETRY', retried: err })
|
||||
}, number, operation)
|
||||
return resolve(result)
|
||||
} catch (err) {
|
||||
if (isRetryError(err)) {
|
||||
if (operation.retry(err.retried || new Error())) {
|
||||
return
|
||||
}
|
||||
return reject(err.retried)
|
||||
}
|
||||
return reject(err)
|
||||
}
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
module.exports = { promiseRetry }
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
{
|
||||
"name": "@gar/promise-retry",
|
||||
"version": "1.0.2",
|
||||
"description": "Retries a function that returns a promise, leveraging the power of the retry module.",
|
||||
"main": "./lib/index.js",
|
||||
"files": [
|
||||
"lib"
|
||||
],
|
||||
"type": "commonjs",
|
||||
"exports": {
|
||||
".": [
|
||||
{
|
||||
"default": "./lib/index.js",
|
||||
"types": "./lib/index.d.ts"
|
||||
},
|
||||
"./lib/index.js"
|
||||
]
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "npx standard",
|
||||
"lint:fix": "npx standard --fix",
|
||||
"test": "node --test --experimental-test-coverage --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=100",
|
||||
"typelint": "npx -p typescript tsc ./lib/index.d.ts",
|
||||
"posttest": "npm run lint",
|
||||
"postlint": "npm run typelint"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/wraithgar/node-promise-retry/issues/"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/wraithgar/node-promise-retry.git"
|
||||
},
|
||||
"keywords": [
|
||||
"retry",
|
||||
"promise",
|
||||
"backoff",
|
||||
"repeat",
|
||||
"replay"
|
||||
],
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"retry": "^0.13.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": "^20.17.0 || >=22.9.0"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user