@electerm/nedb 1.10.0 → 2.0.0

package/lib/async.js

@@ -0,0 +1,237 @@
+/**
+ * Custom async utilities to replace the async library
+ * Uses modern async/await internally while maintaining callback compatibility
+ */
+
+/**
+ * Promisify a callback-based function
+ */
+function promisify(fn) {
+  return function(...args) {
+    return new Promise((resolve, reject) => {
+      fn(...args, (err, ...results) => {
+        if (err) reject(err);
+        else resolve(results.length <= 1 ? results[0] : results);
+      });
+    });
+  };
+}
+
+/**
+ * Execute functions in series (waterfall pattern)
+ * Each function receives the result of the previous function as its parameters (except the last which is always the callback)
+ */
+function waterfall(tasks, finalCallback) {
+  finalCallback = finalCallback || function() {};
+  
+  if (!Array.isArray(tasks) || tasks.length === 0) {
+    return finalCallback(null);
+  }
+  
+  let taskIndex = 0;
+  
+  function runNextTask(err, ...results) {
+    if (err) {
+      return finalCallback(err);
+    }
+    
+    if (taskIndex >= tasks.length) {
+      return finalCallback(null, ...results);
+    }
+    
+    const task = tasks[taskIndex++];
+    
+    try {
+      if (typeof task === 'function') {
+        // Regular function
+        if (taskIndex === 1) {
+          // First task gets only the callback
+          task(runNextTask);
+        } else {
+          // Subsequent tasks get results from previous task, then callback
+          task(...results, runNextTask);
+        }
+      } else if (task && task.__async_apply) {
+        // Handle async.apply case
+        const args = [...task.args];
+        if (taskIndex > 1) {
+          // If not the first task, add results from previous task
+          args.push(...results);
+        }
+        args.push(runNextTask);
+        task.fn.apply(null, args);
+      } else {
+        return finalCallback(new Error('Invalid task in waterfall'));
+      }
+    } catch (error) {
+      return finalCallback(error);
+    }
+  }
+  
+  runNextTask();
+}
+
+/**
+ * Apply partial application to a function (like async.apply)
+ */
+function apply(fn, ...args) {
+  return {
+    __async_apply: true,
+    fn: fn,
+    args: args
+  };
+}
+
+/**
+ * Execute a function for each item in an array, in series
+ */
+function eachSeries(array, iterator, callback) {
+  callback = callback || function() {};
+  
+  let index = 0;
+  
+  function processNext(err) {
+    if (err) {
+      return callback(err);
+    }
+    
+    if (index >= array.length) {
+      return callback(null);
+    }
+    
+    const item = array[index++];
+    
+    try {
+      iterator(item, processNext);
+    } catch (error) {
+      return callback(error);
+    }
+  }
+  
+  processNext();
+}
+
+/**
+ * Execute a function for each item in an array, in parallel
+ */
+function each(array, iterator, callback) {
+  callback = callback || function() {};
+  
+  if (array.length === 0) {
+    return callback(null);
+  }
+  
+  let completed = 0;
+  let hasError = false;
+  
+  array.forEach(function(item) {
+    iterator(item, function(err) {
+      if (hasError) return;
+      
+      if (err) {
+        hasError = true;
+        return callback(err);
+      }
+      
+      completed++;
+      if (completed === array.length) {
+        callback(null);
+      }
+    });
+  });
+}
+
+/**
+ * Execute a function repeatedly while a condition is true
+ */
+function whilst(test, iterator, callback) {
+  callback = callback || function() {};
+  
+  function iterate(err) {
+    if (err) {
+      return callback(err);
+    }
+    
+    if (!test()) {
+      return callback(null);
+    }
+    
+    try {
+      iterator(iterate);
+    } catch (error) {
+      return callback(error);
+    }
+  }
+  
+  iterate();
+}
+
+/**
+ * Task queue implementation
+ */
+function queue(worker, concurrency = 1) {
+  const tasks = [];
+  let running = 0;
+  let paused = false;
+
+  function processTasks() {
+    while (tasks.length > 0 && running < concurrency && !paused) {
+      const task = tasks.shift();
+      running++;
+      
+      worker(task.data, function(err) {
+        running--;
+        task.callback(err);
+        
+        // Process next tasks
+        if (tasks.length > 0) {
+          setImmediate(processTasks);
+        }
+      });
+    }
+  }
+
+  return {
+    push: function(data, callback) {
+      callback = callback || function() {};
+      tasks.push({ data, callback });
+      setImmediate(processTasks);
+    },
+    
+    unshift: function(data, callback) {
+      callback = callback || function() {};
+      tasks.unshift({ data, callback });
+      setImmediate(processTasks);
+    },
+    
+    pause: function() {
+      paused = true;
+    },
+    
+    resume: function() {
+      paused = false;
+      setImmediate(processTasks);
+    },
+    
+    length: function() {
+      return tasks.length;
+    },
+    
+    running: function() {
+      return running;
+    },
+    
+    idle: function() {
+      return tasks.length === 0 && running === 0;
+    }
+  };
+}
+
+module.exports = {
+  waterfall,
+  apply,
+  eachSeries,
+  each,
+  whilst,
+  queue
+};

package/lib/cursor.js

@@ -2,7 +2,7 @@
  * Manage access to data, be it to find, update or remove it
  */
 var model = require('./model')
-  , _ = require('lodash')
+  , _ = require('./underscore')
   ;
 
 

package/lib/datastore.js

@@ -1,14 +1,16 @@
 var customUtils = require('./customUtils')
   , model = require('./model')
-  , async = require('async')
+  , async = require('./async')
   , Executor = require('./executor')
   , Index = require('./indexes')
-  , util = require('util')
-  , _ = require('lodash')
+  , util = require('./util')
+  , _ = require('./underscore')
   , Persistence = require('./persistence')
   , Cursor = require('./cursor')
   ;
 
+var isDate = util.isDate;
+
 
 /**
  * Create a new collection
@@ -269,7 +271,7 @@ Datastore.prototype.getCandidates = function (query, dontExpireStaleDocs, callba
     // For a basic match
     usableQueryKeys = [];
     Object.keys(query).forEach(function (k) {
-      if (typeof query[k] === 'string' || typeof query[k] === 'number' || typeof query[k] === 'boolean' || util.isDate(query[k]) || query[k] === null) {
+      if (typeof query[k] === 'string' || typeof query[k] === 'number' || typeof query[k] === 'boolean' || isDate(query[k]) || query[k] === null) {
         usableQueryKeys.push(k);
       }
     });
@@ -314,7 +316,7 @@ Datastore.prototype.getCandidates = function (query, dontExpireStaleDocs, callba
     docs.forEach(function (doc) {
       var valid = true;
       ttlIndexesFieldNames.forEach(function (i) {
-        if (doc[i] !== undefined && util.isDate(doc[i]) && Date.now() > doc[i].getTime() + self.ttlIndexes[i] * 1000) {
+        if (doc[i] !== undefined && isDate(doc[i]) && Date.now() > doc[i].getTime() + self.ttlIndexes[i] * 1000) {
           valid = false;
         }
       });
@@ -351,7 +353,7 @@ Datastore.prototype._insert = function (newDoc, cb) {
     return callback(e);
   }
 
-  this.persistence.persistNewState(util.isArray(preparedDoc) ? preparedDoc : [preparedDoc], function (err) {
+  this.persistence.persistNewState(Array.isArray(preparedDoc) ? preparedDoc : [preparedDoc], function (err) {
     if (err) { return callback(err); }
     return callback(null, model.deepCopy(preparedDoc));
   });
@@ -377,7 +379,7 @@ Datastore.prototype.createNewId = function () {
 Datastore.prototype.prepareDocumentForInsertion = function (newDoc) {
   var preparedDoc, self = this;
 
-  if (util.isArray(newDoc)) {
+  if (Array.isArray(newDoc)) {
     preparedDoc = [];
     newDoc.forEach(function (doc) { preparedDoc.push(self.prepareDocumentForInsertion(doc)); });
   } else {
@@ -397,7 +399,7 @@ Datastore.prototype.prepareDocumentForInsertion = function (newDoc) {
  * @api private
  */
 Datastore.prototype._insertInCache = function (preparedDoc) {
-  if (util.isArray(preparedDoc)) {
+  if (Array.isArray(preparedDoc)) {
     this._insertMultipleDocsInCache(preparedDoc);
   } else {
     this.addToIndexes(preparedDoc);

package/lib/executor.js

@@ -2,7 +2,7 @@
  * Responsible for sequentially executing actions on the database
  */
 
-var async = require('async')
+var async = require('./async')
   ;
 
 function Executor () {

package/lib/indexes.js

@@ -1,9 +1,11 @@
 var BinarySearchTree = require('@yetzt/binary-search-tree').AVLTree
   , model = require('./model')
-  , _ = require('lodash')
-  , util = require('util')
+  , _ = require('./underscore')
+  , util = require('./util')
   ;
 
+var isDate = util.isDate;
+
 /**
  * Two indexed pointers are equal iif they point to the same place
  */
@@ -19,7 +21,7 @@ function projectForUnique (elt) {
   if (typeof elt === 'string') { return '$string' + elt; }
   if (typeof elt === 'boolean') { return '$boolean' + elt; }
   if (typeof elt === 'number') { return '$number' + elt; }
-  if (util.isArray(elt)) { return '$date' + elt.getTime(); }
+  if (isDate(elt)) { return '$date' + elt.getTime(); }
 
   return elt;   // Arrays and objects, will check for pointer equality
 }
@@ -66,14 +68,14 @@ Index.prototype.insert = function (doc) {
     , keys, i, failingI, error
     ;
 
-  if (util.isArray(doc)) { this.insertMultipleDocs(doc); return; }
+  if (Array.isArray(doc)) { this.insertMultipleDocs(doc); return; }
 
   key = model.getDotValue(doc, this.fieldName);
 
   // We don't index documents that don't contain the field if the index is sparse
   if (key === undefined && this.sparse) { return; }
 
-  if (!util.isArray(key)) {
+  if (!Array.isArray(key)) {
     this.tree.insert(key, doc);
   } else {
     // If an insert fails due to a unique constraint, roll back all inserts before it
@@ -138,13 +140,13 @@ Index.prototype.insertMultipleDocs = function (docs) {
 Index.prototype.remove = function (doc) {
   var key, self = this;
 
-  if (util.isArray(doc)) { doc.forEach(function (d) { self.remove(d); }); return; }
+  if (Array.isArray(doc)) { doc.forEach(function (d) { self.remove(d); }); return; }
 
   key = model.getDotValue(doc, this.fieldName);
 
   if (key === undefined && this.sparse) { return; }
 
-  if (!util.isArray(key)) {
+  if (!Array.isArray(key)) {
     this.tree.delete(key, doc);
   } else {
     _.uniq(key, projectForUnique).forEach(function (_key) {
@@ -160,7 +162,7 @@ Index.prototype.remove = function (doc) {
  * Naive implementation, still in O(log(n))
  */
 Index.prototype.update = function (oldDoc, newDoc) {
-  if (util.isArray(oldDoc)) { this.updateMultipleDocs(oldDoc); return; }
+  if (Array.isArray(oldDoc)) { this.updateMultipleDocs(oldDoc); return; }
 
   this.remove(oldDoc);
 
@@ -219,7 +221,7 @@ Index.prototype.updateMultipleDocs = function (pairs) {
 Index.prototype.revertUpdate = function (oldDoc, newDoc) {
   var revert = [];
 
-  if (!util.isArray(oldDoc)) {
+  if (!Array.isArray(oldDoc)) {
     this.update(newDoc, oldDoc);
   } else {
     oldDoc.forEach(function (pair) {
@@ -238,7 +240,7 @@ Index.prototype.revertUpdate = function (oldDoc, newDoc) {
 Index.prototype.getMatching = function (value) {
   var self = this;
 
-  if (!util.isArray(value)) {
+  if (!Array.isArray(value)) {
     return self.tree.search(value);
   } else {
     var _res = {}, res = [];

package/lib/model.js

@@ -5,8 +5,8 @@
  * Querying, update
  */
 
-var util = require('util')
-  , _ = require('lodash')
+var util = require('./util')
+  , _ = require('./underscore')
   , modifierFunctions = {}
   , lastStepModifierFunctions = {}
   , comparisonFunctions = {}
@@ -14,6 +14,9 @@ var util = require('util')
   , arrayComparisonFunctions = {}
   ;
 
+var isDate = util.isDate;
+var isRegExp = util.isRegExp;
+
 
 /**
  * Check a key, throw an error if the key is non valid
@@ -43,7 +46,7 @@ function checkKey (k, v) {
  * Works by applying the above checkKey function to all fields recursively
  */
 function checkObject (obj) {
-  if (util.isArray(obj)) {
+  if (Array.isArray(obj)) {
     obj.forEach(function (o) {
       checkObject(o);
     });
@@ -113,11 +116,11 @@ function deepCopy (obj, strictKeys) {
        typeof obj === 'number' ||
        typeof obj === 'string' ||
        obj === null ||
-       (util.isDate(obj)) ) {
+       (isDate(obj)) ) {
     return obj;
   }
 
-  if (util.isArray(obj)) {
+  if (Array.isArray(obj)) {
     res = [];
     obj.forEach(function (o) { res.push(deepCopy(o, strictKeys)); });
     return res;
@@ -146,8 +149,8 @@ function isPrimitiveType (obj) {
        typeof obj === 'number' ||
        typeof obj === 'string' ||
        obj === null ||
-       util.isDate(obj) ||
-       util.isArray(obj));
+       isDate(obj) ||
+       Array.isArray(obj));
 }
 
 
@@ -211,12 +214,12 @@ function compareThings (a, b, _compareStrings) {
   if (typeof b === 'boolean') { return typeof a === 'boolean' ? compareNSB(a, b) : 1; }
 
   // Dates
-  if (util.isDate(a)) { return util.isDate(b) ? compareNSB(a.getTime(), b.getTime()) : -1; }
-  if (util.isDate(b)) { return util.isDate(a) ? compareNSB(a.getTime(), b.getTime()) : 1; }
+  if (isDate(a)) { return isDate(b) ? compareNSB(a.getTime(), b.getTime()) : -1; }
+  if (isDate(b)) { return isDate(a) ? compareNSB(a.getTime(), b.getTime()) : 1; }
 
   // Arrays (first element is most significant and so on)
-  if (util.isArray(a)) { return util.isArray(b) ? compareArrays(a, b) : -1; }
-  if (util.isArray(b)) { return util.isArray(a) ? compareArrays(a, b) : 1; }
+  if (Array.isArray(a)) { return Array.isArray(b) ? compareArrays(a, b) : -1; }
+  if (Array.isArray(b)) { return Array.isArray(a) ? compareArrays(a, b) : 1; }
 
   // Objects
   aKeys = Object.keys(a).sort();
@@ -272,7 +275,7 @@ lastStepModifierFunctions.$push = function (obj, field, value) {
   // Create the array if it doesn't exist
   if (!obj.hasOwnProperty(field)) { obj[field] = []; }
 
-  if (!util.isArray(obj[field])) { throw new Error("Can't $push an element on non-array values"); }
+  if (!Array.isArray(obj[field])) { throw new Error("Can't $push an element on non-array values"); }
 
   if (value !== null && typeof value === 'object' && value.$slice && value.$each === undefined) {
     value.$each = [];
@@ -280,7 +283,7 @@ lastStepModifierFunctions.$push = function (obj, field, value) {
 
   if (value !== null && typeof value === 'object' && value.$each) {
     if (Object.keys(value).length >= 3 || (Object.keys(value).length === 2 && value.$slice === undefined)) { throw new Error("Can only use $slice in cunjunction with $each when $push to array"); }
-    if (!util.isArray(value.$each)) { throw new Error("$each requires an array value"); }
+    if (!Array.isArray(value.$each)) { throw new Error("$each requires an array value"); }
 
     value.$each.forEach(function (v) {
       obj[field].push(v);
@@ -318,11 +321,11 @@ lastStepModifierFunctions.$addToSet = function (obj, field, value) {
   // Create the array if it doesn't exist
   if (!obj.hasOwnProperty(field)) { obj[field] = []; }
 
-  if (!util.isArray(obj[field])) { throw new Error("Can't $addToSet an element on non-array values"); }
+  if (!Array.isArray(obj[field])) { throw new Error("Can't $addToSet an element on non-array values"); }
 
   if (value !== null && typeof value === 'object' && value.$each) {
     if (Object.keys(value).length > 1) { throw new Error("Can't use another field in conjunction with $each"); }
-    if (!util.isArray(value.$each)) { throw new Error("$each requires an array value"); }
+    if (!Array.isArray(value.$each)) { throw new Error("$each requires an array value"); }
 
     value.$each.forEach(function (v) {
       lastStepModifierFunctions.$addToSet(obj, field, v);
@@ -340,7 +343,7 @@ lastStepModifierFunctions.$addToSet = function (obj, field, value) {
  * Remove the first or last element of an array
  */
 lastStepModifierFunctions.$pop = function (obj, field, value) {
-  if (!util.isArray(obj[field])) { throw new Error("Can't $pop an element from non-array values"); }
+  if (!Array.isArray(obj[field])) { throw new Error("Can't $pop an element from non-array values"); }
   if (typeof value !== 'number') { throw new Error(value + " isn't an integer, can't use it with $pop"); }
   if (value === 0) { return; }
 
@@ -358,7 +361,7 @@ lastStepModifierFunctions.$pop = function (obj, field, value) {
 lastStepModifierFunctions.$pull = function (obj, field, value) {
   var arr, i;
 
-  if (!util.isArray(obj[field])) { throw new Error("Can't $pull an element from non-array values"); }
+  if (!Array.isArray(obj[field])) { throw new Error("Can't $pull an element from non-array values"); }
 
   arr = obj[field];
   for (i = arr.length - 1; i >= 0; i -= 1) {
@@ -500,7 +503,7 @@ function getDotValue (obj, field) {
 
   if (fieldParts.length === 1) { return obj[fieldParts[0]]; }
 
-  if (util.isArray(obj[fieldParts[0]])) {
+  if (Array.isArray(obj[fieldParts[0]])) {
     // If the next field is an integer, return only this item of the array
     i = parseInt(fieldParts[1], 10);
     if (typeof i === 'number' && !isNaN(i)) {
@@ -533,11 +536,11 @@ function areThingsEqual (a, b) {
       b === null || typeof b === 'string' || typeof b === 'boolean' || typeof b === 'number') { return a === b; }
 
   // Dates
-  if (util.isDate(a) || util.isDate(b)) { return util.isDate(a) && util.isDate(b) && a.getTime() === b.getTime(); }
+  if (isDate(a) || isDate(b)) { return isDate(a) && isDate(b) && a.getTime() === b.getTime(); }
 
   // Arrays (no match since arrays are used as a $in)
   // undefined (no match since they mean field doesn't exist and can't be serialized)
-  if ((!(util.isArray(a) && util.isArray(b)) && (util.isArray(a) || util.isArray(b))) || a === undefined || b === undefined) { return false; }
+  if ((!(Array.isArray(a) && Array.isArray(b)) && (Array.isArray(a) || Array.isArray(b))) || a === undefined || b === undefined) { return false; }
 
   // General objects (check for deep equality)
   // a and b should be objects at this point
@@ -561,8 +564,8 @@ function areThingsEqual (a, b) {
  * Check that two values are comparable
  */
 function areComparable (a, b) {
-  if (typeof a !== 'string' && typeof a !== 'number' && !util.isDate(a) &&
-      typeof b !== 'string' && typeof b !== 'number' && !util.isDate(b)) {
+  if (typeof a !== 'string' && typeof a !== 'number' && !isDate(a) &&
+      typeof b !== 'string' && typeof b !== 'number' && !isDate(b)) {
     return false;
   }
 
@@ -601,7 +604,7 @@ comparisonFunctions.$ne = function (a, b) {
 comparisonFunctions.$in = function (a, b) {
   var i;
 
-  if (!util.isArray(b)) { throw new Error("$in operator called with a non-array"); }
+  if (!Array.isArray(b)) { throw new Error("$in operator called with a non-array"); }
 
   for (i = 0; i < b.length; i += 1) {
     if (areThingsEqual(a, b[i])) { return true; }
@@ -611,13 +614,13 @@ comparisonFunctions.$in = function (a, b) {
 };
 
 comparisonFunctions.$nin = function (a, b) {
-  if (!util.isArray(b)) { throw new Error("$nin operator called with a non-array"); }
+  if (!Array.isArray(b)) { throw new Error("$nin operator called with a non-array"); }
 
   return !comparisonFunctions.$in(a, b);
 };
 
 comparisonFunctions.$regex = function (a, b) {
-  if (!util.isRegExp(b)) { throw new Error("$regex operator called with non regular expression"); }
+  if (!isRegExp(b)) { throw new Error("$regex operator called with non regular expression"); }
 
   if (typeof a !== 'string') {
     return false
@@ -642,13 +645,13 @@ comparisonFunctions.$exists = function (value, exists) {
 
 // Specific to arrays
 comparisonFunctions.$size = function (obj, value) {
-    if (!util.isArray(obj)) { return false; }
+    if (!Array.isArray(obj)) { return false; }
     if (value % 1 !== 0) { throw new Error("$size operator called without an integer"); }
 
     return (obj.length == value);
 };
 comparisonFunctions.$elemMatch = function (obj, value) {
-  if (!util.isArray(obj)) { return false; }
+  if (!Array.isArray(obj)) { return false; }
   var i = obj.length;
   var result = false;   // Initialize result
   while (i--) {
@@ -671,7 +674,7 @@ arrayComparisonFunctions.$elemMatch = true;
 logicalOperators.$or = function (obj, query) {
   var i;
 
-  if (!util.isArray(query)) { throw new Error("$or operator used without an array"); }
+  if (!Array.isArray(query)) { throw new Error("$or operator used without an array"); }
 
   for (i = 0; i < query.length; i += 1) {
     if (match(obj, query[i])) { return true; }
@@ -689,7 +692,7 @@ logicalOperators.$or = function (obj, query) {
 logicalOperators.$and = function (obj, query) {
   var i;
 
-  if (!util.isArray(query)) { throw new Error("$and operator used without an array"); }
+  if (!Array.isArray(query)) { throw new Error("$and operator used without an array"); }
 
   for (i = 0; i < query.length; i += 1) {
     if (!match(obj, query[i])) { return false; }
@@ -768,14 +771,14 @@ function matchQueryPart (obj, queryKey, queryValue, treatObjAsValue) {
     , i, keys, firstChars, dollarFirstChars;
 
   // Check if the value is an array if we don't force a treatment as value
-  if (util.isArray(objValue) && !treatObjAsValue) {
+  if (Array.isArray(objValue) && !treatObjAsValue) {
     // If the queryValue is an array, try to perform an exact match
-    if (util.isArray(queryValue)) {
+    if (Array.isArray(queryValue)) {
       return matchQueryPart(obj, queryKey, queryValue, true);
     }
 
     // Check if we are using an array-specific comparison function
-    if (queryValue !== null && typeof queryValue === 'object' && !util.isRegExp(queryValue)) {
+    if (queryValue !== null && typeof queryValue === 'object' && !isRegExp(queryValue)) {
       keys = Object.keys(queryValue);
       for (i = 0; i < keys.length; i += 1) {
         if (arrayComparisonFunctions[keys[i]]) { return matchQueryPart(obj, queryKey, queryValue, true); }
@@ -791,7 +794,7 @@ function matchQueryPart (obj, queryKey, queryValue, treatObjAsValue) {
 
   // queryValue is an actual object. Determine whether it contains comparison operators
   // or only normal fields. Mixed objects are not allowed
-  if (queryValue !== null && typeof queryValue === 'object' && !util.isRegExp(queryValue) && !util.isArray(queryValue)) {
+  if (queryValue !== null && typeof queryValue === 'object' && !isRegExp(queryValue) && !Array.isArray(queryValue)) {
     keys = Object.keys(queryValue);
     firstChars = _.map(keys, function (item) { return item[0]; });
     dollarFirstChars = _.filter(firstChars, function (c) { return c === '$'; });
@@ -812,7 +815,7 @@ function matchQueryPart (obj, queryKey, queryValue, treatObjAsValue) {
   }
 
   // Using regular expressions with basic querying
-  if (util.isRegExp(queryValue)) { return comparisonFunctions.$regex(objValue, queryValue); }
+  if (isRegExp(queryValue)) { return comparisonFunctions.$regex(objValue, queryValue); }
 
   // queryValue is either a native value or a normal object
   // Basic matching is possible

package/lib/persistence.js

@@ -8,7 +8,7 @@
 var storage = require('./storage')
   , path = require('path')
   , model = require('./model')
-  , async = require('async')
+  , async = require('./async')
   , customUtils = require('./customUtils')
   , Index = require('./indexes')
   ;
@@ -72,7 +72,7 @@ Persistence.ensureDirectoryExists = function (dir, cb) {
   var callback = cb || function () {}
     ;
 
-  storage.mkdirp(dir, function (err) { return callback(err); });
+  storage.mkdirp(dir).then(function() { return callback(); }).catch(callback);
 };
 
 

package/lib/storage.js

@@ -9,7 +9,7 @@
 
 var fs = require('fs')
   , mkdirp = require('mkdirp')
-  , async = require('async')
+  , async = require('./async')
   , path = require('path')
   , storage = {}
   ;