async-queue-js

A generic async queue with a single dependency on bluebird
It's very useful for making transactions to APIs that don't support simultaneous requests

Installation

npm

npm install async-queue-js

yarn

yarn add async-queue-js

Examples

Creating a queue

const AsyncQueue = require('async-queue-js')
const queue = new AsyncQueue()

Setting timeout (default is 60000ms)

const AsyncQueue = require('async-queue-js')
const queue = new AsyncQueue({timeout: 10000})

The timeout will be applied to each separate operation in the queue

Enqueuing a non async function

const queue = new AsyncQueue()

function nonAsync() {
  return 'Just a normal function'
}

queue.enqueue(nonAsync)

Enqueuing an async function

const queue = new AsyncQueue()

function asyncOperation() {
  return new Promise((resolve) => {
    resolve('Promises are cooler though')
  })
}

queue.enqueue(asyncOperation)

Once an operation is enqueued its execution starts immediately
Any subsequent enqueued operations wait for its completion in order to start

Passing arguments

First argument is always the function that will be executed
The rest of the arguments will be passed to that function

const queue = new AsyncQueue()

function praiseCats(arg1, arg2, arg3) {
  console.log(arg1, arg2, arg3) // 'Cats are awesome'
}

queue.enqueue(praiseCats, 'Cats', 'are', 'awesome')

Registering handlers

Handlers can be registered on the enqueue method

queue.enqueue(asyncOperation)
.then(res => {
  // do something with the result
  return res
})
.catch(error => {
  // handle errors
  throw error
})

Functions are automatically promisified

A more realistic use case

This example uses an express instance and assumes that it is already up and running

const app = require('./app')

const AsyncQueue = require('async-queue-js')
const queue = new AsyncQueue()

const transact = require('./transact')

app.post('/transact', (req, res) => {
  // validate the request
  queue.enqueue(transact, req.body)
  .then(resp => {
    return res.json({message: 'Your payment was successful', amount: resp.amount})
  })
  .catch(error => {
    return res.json({error: error.message})
  })
})

Note: transact makes a request to a third party provider which requires transactions to be made 1 by 1

Start/stop the continuous drain

To stop the continuous drain

const queue = new AsyncQueue()
queue.stop()

While the drain is stopped you can still enqueue operations
Once you call

queue.start()

The queue will continue the drain

Events

const queue = new AsyncQueue()

queue.on('enqueue', (operation) => {
  console.log('An operation has been enqueued and will begin its execution once its first in the queue')
})

queue.on('dequeue', (operation) => {
  console.log('An operation has been dequeued and will begin its execution immediately')
})

queue.on('empty', () => {
  console.log('The queue is drained. Once a new operation is enqueued it will continue')
})

queue.on('stop', () => {
  console.log('The drain is stopped')
})

queue.on('start', () => {
  console.log('The drain is started')
})

License

MIT