async-done

What is async-done?

The async-done npm package is a utility for handling asynchronous tasks in Node.js. It provides a simple way to manage callbacks, promises, observables, and streams, making it easier to work with various types of asynchronous operations.

What are async-done's main functionalities?

Handling Callbacks

This feature allows you to handle asynchronous tasks that use callbacks. The `asyncDone` function takes a task function and a callback to handle the result or error.

const asyncDone = require('async-done');

function callbackTask(done) {
  setTimeout(() => {
    done(null, 'Callback Task Completed');
  }, 1000);
}

asyncDone(callbackTask, (err, result) => {
  if (err) throw err;
  console.log(result); // Output: Callback Task Completed
});

Handling Promises

This feature allows you to handle asynchronous tasks that return promises. The `asyncDone` function can manage the promise and handle the result or error.

const asyncDone = require('async-done');

function promiseTask() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('Promise Task Completed');
    }, 1000);
  });
}

asyncDone(promiseTask, (err, result) => {
  if (err) throw err;
  console.log(result); // Output: Promise Task Completed
});

Handling Observables

This feature allows you to handle asynchronous tasks that return observables. The `asyncDone` function can manage the observable and handle the result or error.

const asyncDone = require('async-done');
const { Observable } = require('rxjs');

function observableTask() {
  return new Observable((observer) => {
    setTimeout(() => {
      observer.next('Observable Task Completed');
      observer.complete();
    }, 1000);
  });
}

asyncDone(observableTask, (err, result) => {
  if (err) throw err;
  console.log(result); // Output: Observable Task Completed
});

Handling Streams

This feature allows you to handle asynchronous tasks that return streams. The `asyncDone` function can manage the stream and handle the result or error.

const asyncDone = require('async-done');
const { Readable } = require('stream');

function streamTask() {
  const stream = new Readable();
  stream._read = () => {};
  setTimeout(() => {
    stream.push('Stream Task Completed');
    stream.push(null);
  }, 1000);
  return stream;
}

asyncDone(streamTask, (err, result) => {
  if (err) throw err;
  console.log(result); // Output: Stream Task Completed
});

Other packages similar to async-done

async

The async package provides a collection of functions for working with asynchronous JavaScript. It offers utilities for handling asynchronous control flow using callbacks, promises, and async/await. Compared to async-done, async provides a broader range of utilities for managing complex asynchronous workflows.

bluebird

Bluebird is a fully-featured promise library for JavaScript. It provides advanced promise management features, including cancellation, iteration, and resource management. Compared to async-done, Bluebird focuses specifically on promises and offers more advanced promise-related functionalities.

rxjs

RxJS is a library for reactive programming using observables. It provides powerful operators for composing asynchronous and event-based programs. Compared to async-done, RxJS focuses on observables and offers a comprehensive set of tools for working with reactive streams.

README

async-done

Manage callback, promise, and stream completion

Will run call the executor function on nextTick. This will cause all functions to be async.

Usage

Successful completion

var asyncDone = require('async-done');

asyncDone(function(done){
  // do async things
  done(null, 2);
}, function(error, result){
  // `error` will be undefined on successful execution of the first function.
  // `result` will be the result from the first function.
});

Failed completion

var asyncDone = require('async-done');

asyncDone(function(done){
  // do async things
  done(new Error('Some Error Occurred'));
}, function(error, result){
  // `error` will be an error from the first function.
  // `result` will be undefined on failed execution of the first function.
});

API

asyncDone(executor, onComplete) : Function

Takes a function to execute (executor) and a function to call on completion (onComplete).

executor([done]) : Function

Optionally takes a callback to call when async tasks are complete.

If a Stream (or any instance of EventEmitter) or Promise is returned from the executor function, they will be used to wire up the async resolution.

Streams (or any instance of EventEmitter) will be wrapped in a domain for error management. The end and close events will be used to resolve successfully.

Promises will be listened for on the then method. They will use the onFulfilled to resolve successfully or the onRejected methods to resolve with an error.

If you want to write a sync function, it will be executed on process.nextTick and the results will be passed into onComplete.

onComplete(error, result) : Function

If an error doesn't occur in the execution of the executor function, the onComplete method will receive the results as its second argument.

If an error occurred in the execution of the executor function, The onComplete method will receive an error as its first argument.

Errors can be caused by:

• A thrown error
• An error passed to a done callback
• An error event emitted on a returned Stream or EventEmitter
• A rejection of a returned Promise

License

MIT