Async Functional Utils (afunk)

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.

Installation

NPM:

npm install afunk -S

Yarn:

yarn add afunk --save

Usage

API

• batch
• compose
• filter
• handle
• handleCompose
• handlePipe
• map
• pipe
• reduce
• sleep
• timeout

batch

batch(Promise, { batchSize?: number; }) => (Array<any>) : Promise<response>

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]

compose

compose(...Promises<any>) => (any) : Promise<any>

Compose multiple promises. Composes from right to left.

Example:

import { compose } from "afunk";

const result = await compose(
  (x) => Promise.resolve(`${x}?`), // '8?'
  (x) => Promise.resolve(x + 2), // 8
  (x) => Promise.resolve(x * 2) // 6
)(3);

filter

filter(Promise) => (Array<any>) : Promise<response>

Filters over an array async.

Example:

import { filter } from "afunk";

const result = await filter((x) => {
  return Promise.resolve(x.includes("hi"));
})(["hi", "high", "hay"]);

console.log(result); // ["hi", "hey"]

handle

handle(Promise<any>) => [Error, Response]

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 "afunk";

const [error, response] = await handle(api.deleteEverything);

if (error) {
  console.log(error);
}

if (response) {
  console.log(response);
}

handleCompose

handleCompose(...Promises<any>) => (any) : Promise<[error, response]>

The same as compose, but wrapped in a handle. Returns an array of [error, response]

Example:

import { handleCompose } from "afunk";

const [result, error] = await handleCompose(
  (x) => Promise.resolve(`${x}?`), // '8?'
  (x) => Promise.resolve(x + 2), // 8
  (x) => Promise.resolve(x * 2) // 6
)(3);

handlePipe

handlePipe(...Promises<any>) => (any) : Promise<[error, response]>

The same as pipe, but wrapped in a handle. Returns an array of [error, response]

Example:

import { handlePipe } from "afunk";

const [error, result] = await handlePipe(
  (x) => Promise.resolve(x * 2), // 6
  (x) => Promise.resolve(x + 2), // 8
  (x) => Promise.resolve(`${x}?`) // '8?'
)(3);

map

map(Promise) => (Array<any>) : Promise<response>

Maps over an array async.

Example:

import { map } from "afunk";

const result = await map((x) => Promise.resolve(x * 3))([1, 2, 3]);

console.log(result); // [3, 6, 9]

pipe

pipe(...Promises<any>) => (any) : Promise<any>

Compose multiple promises. Each will pass its results to the next.

Example:

import { pipe } from "afunk";

const result = await pipe(
  (x) => Promise.resolve(x * 2), // 6
  (x) => Promise.resolve(x + 2), // 8
  (x) => Promise.resolve(`${x}?`) // '8?'
)(3);

reduce

reduce(Promise, ?initialValue) => (Array<any>) : Promise<response>

Reduces over an array async.

Example:

import { reduce } from "afunk";

const [six, seven] = await reduce((prev, x) => {
  return Promise.resolve([...prev, x + 5]);
}, [])([1, 2]);

console.log(six); // 6

sleep

(milliseconds: number) => (any) : Promise<response>

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'

timeout

timeout({ wait: number, errorMessage?: string }, () => Promise<any> => any : Promise<any>

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
  )
);