Skip to content
limits calls to functions that return promises
JavaScript TypeScript
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.
example feat: add index.d.ts Feb 26, 2018
test feat: add index.d.ts Feb 26, 2018
.eslintrc es5 compatibility, can be used in older browsers Jul 25, 2017
.gitignore git ignoring .vimrc May 17, 2016
.travis.yml Add "We're Hiring!" to README Feb 9, 2018
index.d.ts Update index.d.ts Jul 28, 2018
index.js es5 compatibility, can be used in older browsers Jul 25, 2017

promise-limit npm version npm Build Status

Limit outstanding calls to promise returning functions, or a semaphore for promises. You might want to do this to reduce load on external services, or reduce memory usage when processing large batches of jobs.

npm install promise-limit
var promiseLimit = require('promise-limit')

var limit = promiseLimit(2)

var jobs = ['a', 'b', 'c', 'd', 'e']

Promise.all( => {
  return limit(() => job(name))
})).then(results => {
  console.log('results:', results)

function job (name) {
  var text = `job ${name}`
  console.log('started', text)

  return new Promise(function (resolve) {
    setTimeout(() => {
      console.log('       ', text, 'finished')
    }, 100)

will output:

started job a
started job b
        job a finished
        job b finished
started job c
started job d
        job c finished
        job d finished
started job e
        job e finished

results: [ 'job a', 'job b', 'job c', 'job d', 'job e' ]


var promiseLimit = require('promise-limit')

promiseLimit(concurrency?: Number) -> limit

Returns a function that can be used to wrap promise returning functions, limiting them to concurrency outstanding calls.

  • concurrency the concurrency, i.e. 1 will limit calls to one at a time, effectively in sequence or serial. 2 will allow two at a time, etc. 0 or undefined specify no limit, and all calls will be run in parallel.


limit(fn: () -> Promise<T>) -> Promise<T>

A function that limits calls to fn, based on concurrency above. Returns a promise that resolves or rejects the same value or error as fn. All functions are executed in the same order in which they were passed to limit. fn must return a promise.

  • fn a function that is called with no arguments and returns a promise. You can pass arguments to your function by putting it inside another function, i.e. () -> myfunc(a, b, c). [T], mapper: (T) -> Promise<R>) -> Promise<[R]>

Maps an array of items using mapper, but limiting the number of concurrent calls to mapper with the concurrency of limit. If at least one call to mapper returns a rejected promise, the result of map is a the same rejected promise, and no further calls to mapper are made.


limit.queue: Number

Returns the queue length, the number of jobs that are waiting to be started. You could use this to throttle incoming jobs, so the queue doesn't overwhealm the available memory - for e.g. pause() a stream.

We're Hiring!

Featurist provides full stack, feature driven development teams. Want to join us? Check out our career opportunities.

You can’t perform that action at this time.