Mongodb support

lib/resourceful/engines/mongodb.js

@@ -0,0 +1,299 @@
+var url = require('url'),
+    async = require('async'),
+    mongodb = require('mongodb'),
+    common = require('../common'),
+    resourceful = require('../../resourceful'),
+    Db = mongodb.Db,
+    Server = mongodb.Server,
+    Connection = mongodb.Connection;
+
+var Mongodb = exports.Mongodb = function Mongodb (config) {
+  if (config.uri) {
+    var parsed = url.parse('mongodb://'+config.uri);
+    config.uri = parsed.hostname;
+    config.port = parseInt(parsed.port, 10);
+    config.database = (parsed.pathname || '').replace(/^\//, '');
+  }
+
+  this.user = config.auth ? config.auth.user : config.user || null;
+  this.pass = config.auth ? config.auth.pass : config.pass || null;
+
+  this.db = new Db(config.database || resourceful.env || 'test',
+    new Server(config.host || config.uri || '127.0.0.1',
+      config.port || 27017));
+
+  this.collection = config.collection || 'resourceful';
+
+  this.cache = new resourceful.Cache();
+};
+
+Mongodb.prototype.protocol = 'mongodb';
+
+Mongodb.prototype.setup = function (cb) {
+  var self = this;
+
+  if (this.callbacks === undefined) {
+    this.callbacks = [];
+  }
+
+  this.callbacks.push(cb);
+
+  var callbacks = function () {
+    for (var i in self.callbacks)
+    {
+      self.callbacks[i].apply(this, arguments);
+    }
+  }
+
+  var getCollection = function () {
+    self.db.collection(self.collection, function (err, collection) {
+      if (err) return callbacks(err);
+
+      self.client = collection;
+      return callbacks(null);
+    });
+  };
+
+  var authenticate = function () {
+    self.db.authenticate(self.user, self.pass, function (err, result) {
+      if (err) {
+        return callbacks(err);
+      }
+      if (result !== true) {
+        return callbacks(new Error('Failed to authenticate'));
+      }
+      return getCollection();
+    });
+  };
+
+  if (!this.db.openCalled) {
+    this.db.open(function (err, p_client) {
+      if (err) {
+        return callbacks(err);
+      }
+
+      if (self.user && self.pass) {
+        return authenticate();
+      }
+
+      return getCollection();
+    });
+  }
+};
+
+Mongodb.prototype.request = function (callback) {
+  if (!this.client) {
+    return this.setup(function (err) {
+      if (err) {
+        return callback(err); // sure why not
+      }
+      return callback(null);
+    });
+  }
+  else {
+    return process.nextTick(function (client) {
+      return callback(null);
+    });
+  }
+};
+
+Mongodb.prototype.get = function (id, callback) {
+  var self = this;
+  if (Array.isArray(id)) {
+    var array = [];
+    return async.forEachSeries(id, function (i, cb) {
+      self.get(i, function (err, doc) {
+        if (err) {
+          if (err.status === 404) {
+            doc = null;
+          }
+          else {
+            return cb(err);
+          }
+        }
+
+        array.push(doc);
+
+        return cb(null);
+      });
+    }, function (err) {
+      if (err) return callback(err);
+      callback(null, array);
+    });
+  }
+
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    self.client.findOne({_id: id}, function (err, doc) {
+      if (err) return callback(err);
+
+      if (doc !== null) {
+        doc.id = doc._id;
+        delete doc._id;
+      }
+      else {
+        var error = new Error('Document '+id+' not found.');
+        error.status = 404;
+        return callback(error);
+      }
+
+      return callback(null, doc);
+    });
+  });
+};
+
+Mongodb.prototype.load = function (data) {
+  var self = this;
+  var array = common.clone(data);
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    for (var i in array) {
+      array[i]._id = array[i].id;
+      delete array[i].id;
+    }
+
+    self.client.insert(array, {safe: true}, function (err) {
+      if (err) return callback(err);
+
+      callback(null);
+    });
+  });
+};
+
+Mongodb.prototype.put = function (id, doc, callback) {
+  var self = this;
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    delete doc.id;
+    doc._id = id;
+    self.client.insert(doc, {safe: true}, function (err) {
+      if (err) return callback(err);
+
+      doc.id = id;
+      delete doc._id;
+      callback(null, doc);
+    });
+  });
+};
+
+Mongodb.prototype.post = Mongodb.prototype.create = function (doc, callback) {
+  var self = this;
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    self.client.insert(doc, {safe: true}, function (err, res) {
+      if (err) return callback(err);
+
+      doc.id = res[0]._id;
+      callback(null, doc);
+    });
+  });
+};
+
+Mongodb.prototype.save = function (/*id, doc, callback*/) {
+  var self = this,
+      args = Array.prototype.slice.call(arguments, 0),
+      callback = args.pop(),
+      doc = args.pop(),
+      id = args.pop();
+
+  if (!id && !doc.id) {
+    //no id available, so we must be inserting a new document. same as `post` :D
+    return this.post(doc, callback);
+  }
+
+  if (id) {
+    save = common.clone(doc);
+    save._id = doc.id = id;
+  }
+  else {
+    save = common.clone(doc);
+    save._id = save.id;
+    delete save.id;
+  }
+
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    self.client.save(save, {safe: true}, function (err) {
+      if (err) return callback(err);
+
+      return callback(null, doc);
+    });
+  });
+};
+
+Mongodb.prototype.update = function (id, update, callback) {
+  var self = this;
+  return this.request(function(err) {
+    if (err) return callback(err);
+
+    self.client.update({_id: id}, {$set: update}, {safe: true}, function (err, res) {
+      if (err) return callback(err);
+
+      self.client.findOne({_id: id}, function (err, doc) {
+        if (err) return callback(err);
+
+        doc.id = doc._id;
+        delete doc._id;
+
+        callback(null, doc);
+      });
+    });
+  });
+};
+
+Mongodb.prototype.destroy = function (id, callback) {
+  var self = this;
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    self.client.remove({_id: id}, {safe: true}, function (err, num) {
+      if (err) return callback(err);
+
+      callback(null, self.cache.get(id) || { id: id });
+    });
+  });
+};
+
+Mongodb.prototype.find = function (conditions, callback) {
+  var self = this;
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    self.client.find(conditions).toArray(function (err, res) {
+      if (err) return callback(err);
+
+      var rows = res ? res.map(function (doc) {
+        doc.id = doc._id.split('/').slice(1).join('/');
+        delete doc._id;
+        return doc;
+      }) : [];
+
+      callback(null, rows);
+    });
+  });
+};
+
+Mongodb.prototype.filter = function (filter, callback) {
+  var self = this;
+  var result = [];
+  return this.request(function (err) {
+    if (err) return callback(err);
+
+    self.client.find().each(function (err, doc) {
+      if (err) return callback(err);
+
+      if (doc === null) {
+        return callback(null, result);
+      }
+
+      if (filter(doc)) {
+        result.push(doc);
+      }
+    });
+  });
+};

package.json

@@ -22,6 +22,7 @@
   "dependencies": {
     "async": "0.1.x",
     "cradle": "0.6.x",
+    "mongodb": "1.1.x",
     "i": "0.3.x",
     "revalidator": "0.1.x",
     "node-uuid": "1.3.x"

test/engines/mongodb.js

@@ -0,0 +1,37 @@
+var mongodb = require('mongodb'),
+    Db = mongodb.Db,
+    Server = mongodb.Server,
+    Connection = mongodb.Connection;
+
+var engine = exports;
+
+engine.name = 'mongodb';
+engine.options = {
+  database: 'test',
+  host: '127.0.0.1',
+  port: 27017,
+  collection: 'resourceful'
+};
+
+engine.load = function (resourceful, data, callback) {
+  var db = new Db(engine.options.database,
+    new Server(engine.options.host, engine.options.port));
+
+  db.open(function (err) {
+    if (err) return callback(err);
+
+    db.dropCollection(engine.options.collection, function (err) {
+      //ignore error, probably failed because it didn't exist which is fine
+
+      db.createCollection(engine.options.collection, function (err, collection) {
+        if (err) return callback(err);
+
+        collection.insert(data, {safe: true}, function (err) {
+          if (err) return callback(err);
+
+          return callback(null);
+        });
+      });
+    });
+  });
+};