bottleneck-ex

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:

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

BottleneckEx(options)

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

map(array, fn)

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.

others

Most APIs supported by bottleneck