node package manager
Love JavaScript? Your insights can make it even better. Take the 2017 JavaScript Ecosystem Survey »



Write algorithms that can be re-used for synchronous and asynchronous code using promises and yield

Build Status Dependency Status NPM version


npm install alagator


A fully backwards compatible version of @substack's mkdirp but without writing the algorithm out twice:

var path = require('path')
var fs = require('fs')
var Promise = require('promise')
var alagator = require('alagator')
module.exports = mkdirpFactory(true, Promise.denodeify(fs.mkdir), Promise.denodeify(fs.stat))
module.exports.sync = mkdirpFactory(false, fs.mkdirSync, fs.statSync)
module.exports.mkdirp = module.exports.mkdirP = module.exports
function mkdirpFactory(async, mkdir, stat) {
  var rec = alagator(function *(p, mode, made) {
    if (mode === undefined) {
      mode = 0777 & (~process.umask());
    if (!made) made = null;
    if (typeof mode === 'string') mode = parseInt(mode, 8);
    p = path.resolve(p);
    try {
      yield mkdir(p, mode);
      made = made || p;
    catch (err0) {
      switch (err0.code) {
        case 'ENOENT' :
          made = yield rec(path.dirname(p), mode, made);
          yield rec(p, mode, made);
        // In the case of any other error, just see if there's a dir 
        // there already.  If so, then hooray!  If not, then something 
        // is borked. 
          var stat;
          try {
              stat = yield stat(p);
          catch (err1) {
              throw err0;
          if (!stat.isDirectory()) throw err0;
    return made;
  }, async)
  return rec


alagator(generatorFunction, isAsync)

isAsync defaults to true.

The alagator method takes a generator function, and then either true (for async) or false (for sync). If false is passed, it makes yield act as a pass through, so the method runs fully synchronously. If true is passed, it makes yield await the resolution of a promise (or array of promises) so that the function becomes async (it also uses Promise.nodeify to support both callback and promise based use). The above mkdirp example could be used in any of the following 3 ways:

var mkdirp = require('mkdirp')
mkdirp('/foo/bar', function(err) {
  if (err) throw err
  console.log('/foo/bar exists')
  .then(function() {
    console.log('/foo/bar exists')
console.log('/foo/bar exists')

spawn(generatorFunction, isAsync)

Exactly as above, except the function is immediately called with no arguments.

use with other promise libraries

If you want the promise returned from async versions of your algorithms to be of a specific type (other than promise) we've got you covered. Simply pass a wrap function in place of true:

var Q = require('q')
module.exports = mkdirpFactory(Q, Q.denodeify(fs.mkdir), Q.denodeify(fs.stat))
module.exports.sync = mkdirpFactory(false, fs.mkdirSync, fs.statSync)

This will still make use of the same promise library internally, but externally will exclusively use Q.