This utility library is designed to handle async code using functional paradigms like curry and compose. It is currently a work in progress and more utilities will be added.
NPM:
npm install async-functional-utils -S
Yarn:
yarn add async-functional-utils --save
Wraps a promise in a catch and returns an array of any caught errors as the first item in the array and the response as the second item.
Example:
import { handle } from "async-functional-utils";
const [error, response] = await handle(api.deleteEverything);
if (error) {
console.log(error);
}
if (response) {
console.log(response);
}Compose multiple promises. Each will pass its results to the next.
Example:
import { pipe } from "async-functional-utils";
const result = await pipe(
(x) => Promise.resolve(x * 2), // 6
(x) => Promise.resolve(x + 2), // 8
(x) => Promise.resolve(`${x}?`) // '8?'
)(3);The same as pipe, but wrapped in a handle. Returns an array of [error, response]
Example:
import { handlePipe } from "async-functional-utils";
const [error, result] = await handlePipe(
(x) => Promise.resolve(x * 2), // 6
(x) => Promise.resolve(x + 2), // 8
(x) => Promise.resolve(`${x}?`) // '8?'
)(3);Compose multiple promises. Composes from right to left.
Example:
import { compose } from "async-functional-utils";
const result = await compose(
(x) => Promise.resolve(`${x}?`), // '8?'
(x) => Promise.resolve(x + 2), // 8
(x) => Promise.resolve(x * 2) // 6
)(3);The same as compose, but wrapped in a handle. Returns an array of [error, response]
Example:
import { handleCompose } from "async-functional-utils";
const [result, error] = await handleCompose(
(x) => Promise.resolve(`${x}?`), // '8?'
(x) => Promise.resolve(x + 2), // 8
(x) => Promise.resolve(x * 2) // 6
)(3);Maps over an array async.
Example:
import { map } from "async-functional-utils";
const result = await map((x) => Promise.resolve(x * 3))([1, 2, 3]);
console.log(result); // [3, 6, 9]Reduces over an array async.
Example:
import { reduce } from "async-functional-utils";
const [six, seven] = await reduce((prev, x) => {
return Promise.resolve([...prev, x + 5]);
}, [])([1, 2]);
console.log(six); // 6Filters over an array async.
Example:
import { filter } from "async-functional-utils";
const result = await filter((x) => {
return Promise.resolve(x.includes("hi"));
})(["hi", "high", "hay"]);
console.log(result); // ["hi", "hey"]Executes a given number of promises against an array at a time.
Example:
const result = await batch(
(x) => {
return new Promise((resolve) => {
setTimeout(() => {
resolve(x);
}, 10);
});
},
{
batchSize: 2,
}
)([1, 2, 3, 4, 5]);
console.log(result); // [1, 2, 3, 4, 5]Waits for a certain number of milliseconds and then proceeds.
Example:
console.log("Wait a second...");
const result = await sleep(1000)("Okay"); // Sleep for a second
console.log(result); // 'Okay'If the timeout happens before a response comes back, we resolve an error.
Example:
const [error, result] = await handle(
timeout(
{
wait: 3000,
errorMessage: "Chronologically challenged",
},
longRunningPromise
)
);