https://github.com/NicolasLopes7/ts-async-kit

the easiest API to deal with promises in Typescript. Currently, ↩️ Retrying 🏃‍♂️ looping & 😴 sleeping
https://github.com/NicolasLopes7/ts-async-kit

async async-loop async-sleep promises retry sleep typescript

Last synced: 16 days ago
JSON representation

the easiest API to deal with promises in Typescript. Currently, ↩️ Retrying 🏃‍♂️ looping & 😴 sleeping

• Host: GitHub
• URL: https://github.com/NicolasLopes7/ts-async-kit
• Owner: NicolasLopes7
• Created: 2023-02-22T04:50:59.000Z (over 1 year ago)
• Default Branch: master
• Last Pushed: 2024-01-25T04:27:22.000Z (5 months ago)
• Last Synced: 2024-06-03T11:55:56.868Z (25 days ago)
• Topics: async, async-loop, async-sleep, promises, retry, sleep, typescript
• Language: TypeScript
• Homepage:
• Size: 51.8 KB
• Stars: 41
• Watchers: 2
• Forks: 3
• Open Issues: 2
• Metadata Files:
  • Readme: README.md

Lists

• my-awesome-stars - NicolasLopes7/ts-async-kit - the easiest API to deal with promises in Typescript. Currently, ↩️ Retrying 🏃‍♂️ looping & 😴 sleeping (TypeScript)

README

        

# 🚀 ts-async-kit

A lightweight TypeScript library that provides an easy-to-use API for dealing with common promise-related operations such as retrying and looping.

## Installation

To install ts-async-kit in your project, simply run:

```sh

pnpm i ts-async-kit

```

## Usage

### Retry ↩️

Sometimes, a promise may fail due to a temporary issue such as a network error. In such cases, retrying the operation can be a useful strategy. With ts-async-kit, you can easily retry a promise until it succeeds or reaches a maximum number of attempts.

Here's an example:

```ts

import { retry } from 'ts-async-kit';

const fetchData = async () => {

  // Fetch data from an API

};

const result = await retry(fetchData, { maxRetries: 3 })

```

In the above example, fetchData is called up to three times, and the result is logged to the console if successful. If all attempts fail, an error is thrown.

| Parameter | Description |

| ------- | ------- |

| MaxRetries (Optional) | How many times the function will be executed |

| Interval (Optional) | How long the function should wait to retry it again |

| Timeout (Optional) | How long the function should wait until stops the function execution (and fail) |

| backoffFactor (Optional) | How much the interval should increase after each retry |

| onRetry (Optional) | Callback function that can be called with the error when a function is retried |

| onFail (Optional) | Callback function that can be called with the error when the function execution finishes by `MaxRetries` OR `Timeout` |

### Sleep 😴 

Sometimes, you just want to block the current flow of execution and wait a certain time. For you don't waste time searching

on StackOverflow, we shipped a function that easily does that. It's called `sleep`.

Here's an example:

```ts

import { sleep } from 'ts-async-kit'

await sleep(1000) // Time in ms to sleep

```

### Loop (WIP) 🏃‍♂️

Sometimes, you may need to perform a task repeatedly, such as polling an API for updates. With `ts-async-kit`, you can control how your loop will work. Error-tolerant, concurrent operations, until a condition is met, maximum number of iterations and so on...

Here's an example:

```ts

import { map } from 'ts-async-kit';

const data = [1, 2, 3]

const pollApi = async (id: number) => {

  // Poll an API for updates

};

const result = await map(data, pollApi, { concurrency: 2 })

```

In the above example, pollApi is called up until it finishes executing two promises concurrently. If all iterations fail, an error is thrown.

Contributing

We welcome contributions! If you have an idea for a feature or would like to report a bug, please open an issue or submit a pull request.

License

`ts-async-kit` is released under the MIT License.