Conqueue NPM | npm.io

Conqueue

Description

Conqueue is a simple yet powerful asynchronous queue implementation for managing concurrency and controlling the flow of asynchronous tasks. It supports various modes, such as callbacks, promises, FIFO, LIFO, priority, factor and round-robin, providing flexibility for different use cases.

Features

Concurrency Control: Limit the number of concurrent tasks to prevent resource overload.
Task Priority: Assign priorities to tasks for customized task execution order.
Task Timeout: Set a timeout for individual tasks to handle situations where a task takes too long to complete.
Debouncing: Control task execution frequency with debouncing, useful for scenarios with rapid task submissions.
Promise Mode: Execute tasks that return promises, providing seamless integration with promise-based workflows.
Event Handling: Attach event listeners to handle various events, such as task success, failure, done, timeout and queue drain.

Installation

npm install conqueue

Usage

const Queue = require('conqueue');

const job = (taskId, cb) => {
  setTimeout(() => {
    if (taskId === 4) {
      cb(new Error('Biggest error!!!'));
      return;
    }
    cb(null, taskId);
  }, 0);
};

// Create a queue with a concurrency limit of 3
const queue = new Queue(3)
  .process(job)
  .done((err, res) => {
    if (err) console.error(err);
    else console.log(res);
  })
  .success(({ res }) => {
    console.log(`Response: ${res}`);
  })
  .failure((err) => {
    console.error(`Task failed: ${err}`);
  })
  .drain(() => {
    console.log('Queue drain!');
  });

// Add tasks to the queue
for (let i = 0; i < 10; i++) {
  queue.add(i);
}

API Reference

`Queue(concurrency, size = Infinity)`

Constructor:
- concurrency: Maximum number of tasks to be executed concurrently.
- size: Maximum size of the queue (default is Infinity).
Methods:
- add(item: any, options?: AddOptions): Add a task to the queue with optional factor and priority.
- pipe(destination: Queue): Pipe the queue output to another queue.
- timeout(msec: number, onTimeout: function): Set the maximum execution time for each task.
- wait(msec: number): Set a waiting time before processing tasks.
- debounce(count: number, interval: number): Control the execution frequency using debouncing.
- resume(): Resume the execution of the paused queue.
- pause(): Pause the queue to stop processing new tasks.
- clear(): Clear the queue and reset counters.
- process(listener: function): Set a listener function to process each task.
- done(listener: function): Set a listener function called after each task is processed.
- success(listener: function): Set a listener function for successful task execution.
- failure(listener: function): Set a listener function for failed task execution.
- drain(listener: function): Set a listener function called when the queue is drained.
- fifo(): Set the queue mode to First-In-First-Out (default).
- lifo(): Set the queue mode to Last-In-First-Out.
- priority(flag: boolean): Enable or disable priority mode.
- setFactor(factor: boolean): Set a factor for tasks in round-robin mode.
- roundRobin(flag: boolean): Enable or disable round-robin mode.
- promise(): Enable promise mode to execute tasks returning promises.
- callback(): Switch back to callback mode.