dualAPI

Make your module implement dual APIs.
When the method of your module is called, if a callback Function is appended to the arguments, the method works as callback API. Otherwise the method returns a thenable Promise instance.

For example:
This egg module exports two methods.
The egg.fry method returns 'fried egg' if it is called with 'oil', otherwise it returns [Error: burnt egg]. The egg.boil method returns 'boiled egg' if it is called with 'water', otherwise it returns [Error: broken egg]. These are the same as a function that is passed to Promise constructor.
After setting up exports, call require('dual-api').

// `egg` module
 
function fry(resolve, reject, doWith) {
  console.log(`An egg is fried with ${doWith || 'nothing'}.`);
  setTimeout(() => {
    if (doWith === 'oil') {
      resolve('fried egg');
    } else {
      reject(new Error('burnt egg'));
    }
  }, 3000);
}
 
function boil(resolve, reject, doWith) {
  console.log(`An egg is boiled with ${doWith || 'nothing'}.`);
  setTimeout(() => {
    if (doWith === 'water') {
      resolve('boiled egg');
    } else {
      reject(new Error('broken egg'));
    }
  }, 3000);
}
 
exports.fry = fry;
exports.boil = boil;
 
require('dual-api');

A code that uses egg module:

const egg = require('egg');
 
// Call methods as callback API:
 
egg.fry('oil', function(error, returned) {
  if (error) {
    console.error(error);
  } else {
    console.log(`Got a ${returned}.`);
  }
});
 
egg.boil('water', function(error, returned) {
  if (error) {
    console.error(error);
  } else {
    console.log(`Got a ${returned}.`);
  }
});
 
// Call methods as thenable API:
 
egg.fry('oil')
  .then(returned => { console.log(`Got a ${returned}.`); })
  .catch(error => { console.error(error); });
 
egg.boil('water')
  .then(returned => { console.log(`Got a ${returned}.`); })
  .catch(error => { console.error(error); });

Results:

An egg is fried with oil.
Got a fried egg.
An egg is boiled with water.
Got a boiled egg.
An egg is fried with oil.
Got a fried egg.
An egg is boiled with water.
Got a boiled egg.

A single method that is set to module.exports is also supported.
For example, egg-fly module that exports only fry method:

// `egg-fly` module
 
// There is `fry` function.
 
module.exports = fry;
require('dual-api');

A code that uses egg-fly module:

const eggFly = require('egg-fly');
 
// Call method as callback API:
 
eggFly('oil', function(error, returned) {
  if (error) {
    console.error(error);
  } else {
    console.log(`Got a ${returned}.`);
  }
});
 
// Call method as thenable API:
 
eggFly('oil')
  .then(returned => { console.log(`Got a ${returned}.`); })
  .catch(error => { console.error(error); });

By default, all exported methods implement dual APIs.
You can specify methods that implement dual APIs by using exports._dualApi_methodNames array.
For example, the module exports fry, boil and beatUp methods, and only boil and beatUp methods implement dual APIs.

// `egg` module
 
// There are `fry`, `boil` and `beatUp` functions.
 
exports.fry = fry;
exports.boil = boil;
exports.beatUp = beatUp;
 
exports._dualApi_methodNames = ['boil', `beatUp`];
 
require('dual-api');