bottleneck-ex

> Integrate bottleneck and p-throttle

Features

- Most features of bottleneck
- Useful rate limiting
- Simple map function wrapper

Install

> $ npm install --save bottleneck-ex
>
> $ yarn add bottleneck-ex

Usage

Here, the trottled function is called fifth a second:

``javascript
const BottleneckEx = require('bottleneck-ex')

const limiter = new BottleneckEx({ratePerSecond: 5})

const now = Date.now()

const throttled = (n, i) => {
const secDiff = ((Date.now() - now) / 1000).toFixed()
return Promise.resolve((${i}, ${n}): ${secDiff}s)
}

async function test1 () {
const operations = [1, 2, 3, 4, 5, 6]
const msg = await limiter.map(operations, (each, index) => throttled(each, index))
return msg
}

async function test2 () {
const operations = ['a', 'b', 'c', 'd', 'e', 'f']
const msg = await limiter.map(operations, (each, index) => throttled(each, index))
return msg
}

async function test () {
const results = await Promise.all([test1(), test2()])
return results
}

test().then(console.log)

// [ [ '(0, 1): 0s',
// '(1, 2): 0s',
// '(2, 3): 0s',
// '(3, 4): 0s',
// '(4, 5): 0s',
// '(5, 6): 1s' ],
// [ '(0, a): 1s',
// '(1, b): 1s',
// '(2, c): 1s',
// '(3, d): 1s',
// '(4, e): 2s',
// '(5, f): 2s' ] ]
`

API

$3

Constructor: BottleneckEx is a subclass of Bottleneck

> const limiter = new BottleneckEx(options)

- options.maxConcurrent : How many requests can be running at the same time. Default: 0 (unlimited)
- options.minTime : How long to wait after launching a request before launching another one. Default: 0ms
- options.highWater : How long can the queue get? Default: -1 (unlimited)
- options.strategy : Which strategy to use if the queue gets longer than the high water mark. Default: Bottleneck.strategy.LEAK.
- options.rejectOnDrop : When true if a job is dropped its callback will be called with the first argument set to an Error object. If the job was a promise it will be rejected. Default: false
- options.ratePerSecond: Rate limit per second. Must be positive, like 0.5 , 1..etc. Default: 1

$3

Returns a Prmomise which resolves all fn's processing results for array.

> const promise = limiter.map(operations, (each, index) => throttled(each, index))

- array: Array to be processed.
- fn: Function, both sync or async function are available.

$3

Most APIs supported by bottleneck`