Initial commit of mongoose-tree

Author: briankircho

.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+node_modules/

README.md

@@ -0,0 +1,113 @@
+## mongoose-tree
+
+Implements the materialized path strategy for storing a hierarchy of documents with mongoose
+
+# Usage
+
+Install via NPM
+
+    $ npm install mongoose-tree
+
+Then you can use the plugin on your schemas
+
+```javascript
+var tree = require('mongoose-tree');
+
+var UserSchema = new Schema({
+  name : String
+});
+UserSchema.plugin(tree);
+var User = mongoose.model('User', UserSchema);
+
+var adam = new User({ name : 'Adam' });
+var bob = new User({ name : 'Bob' });
+var carol = new User({ name : 'Carol' });
+
+// Set the parent relationships
+bob.parent = adam; 
+carol.parent = bob;
+
+adam.save(function() {
+  bob.save(function() {
+    carol.save();
+  });
+});
+```
+
+At this point in mongoDB you will have documents similar to
+
+    { 
+      "_id" : ObjectId("50136e40c78c4b9403000001"),
+      "name" : "Adam",
+      "path" : "50136e40c78c4b9403000001"
+    }
+    { 
+      "_id" : ObjectId("50136e40c78c4b9403000002"),
+      "name" : "Bob",
+      "parent" : ObjectId("50136e40c78c4b9403000001"),
+      "path" : "50136e40c78c4b9403000001.50136e40c78c4b9403000002"
+    }
+    { 
+      "_id" : ObjectId("50136e40c78c4b9403000003"),
+      "name" : "Carol", 
+      "parent" : ObjectId("50136e40c78c4b9403000002"),
+      "path" : "50136e40c78c4b9403000001.50136e40c78c4b9403000002.50136e40c78c4b9403000003"
+    }
+
+The path is used for recursive methods and is kept up to date by the plugin if the parent is changed
+
+# API
+
+### getChildren
+
+Signature:
+
+    getChildren([recursive], cb);
+
+if recursive is supplied and true subchildren are returned
+
+Based on the above hierarchy:
+
+```javascript
+adam.getChildren(function(err, users) {
+  // users is an array of with the bob document
+});
+
+adam.getChildren(true, function(err, users) {
+  // users is an array with both bob and carol documents
+});
+```
+
+### getAnsestors
+
+Signature:
+
+    getAnsestors(cb);
+
+Based on the above hierarchy:
+
+```javascript
+carol.getAnsestors(function(err, users) {
+  // users is an array of adam and bob
+})
+```
+
+### level
+
+Equal to the level of the hierarchy
+
+```javascript
+carol.level; // equals 3
+```
+
+# Tests
+
+To run the tests install mocha
+
+    npm install mocha -g
+
+and then run
+
+    mocha
+
+

index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/tree');

lib/tree.js

@@ -0,0 +1,100 @@
+
+var Schema = require('mongoose').Schema;
+
+module.exports = exports = tree;
+
+function tree(schema, options) {
+  schema.add({
+    parent : {
+      type : Schema.ObjectId,
+      set : function(val) {
+        if(typeof(val) === "object" && val._id) {
+          return val._id;
+        }
+        return val;
+      },
+      index: true
+    },
+    path : {
+      type : String,
+      index: true
+    }
+  });
+
+  schema.pre('save', function(next) {
+    var isParentChange = this.modifiedPaths.indexOf('parent') !== -1;
+
+    if(this.isNew || isParentChange) {
+      if(!this.parent) {
+        this.path = this._id.toString();
+        return next();
+      }
+
+      var self = this;
+      this.collection.findOne({ _id : this.parent }, function(err, doc) {
+        if(err) return next(err);
+
+        var previousPath = self.path;
+        self.path = doc.path + '.' + self._id.toString();
+
+        if(isParentChange) {
+          // When the parent is changed we must rewrite all children paths as well
+          self.collection.find({ path : { '$regex' : '^' + previousPath + '.' } }, function(err, cursor) {
+            if(err) return next(err);
+
+            var stream = cursor.stream();
+            stream.on('data', function (doc) {
+              var newPath = self.path+doc.path.substr(previousPath.length);
+              self.collection.update({ _id : doc._id }, { $set : { path : newPath } });
+            });
+            stream.on('close', function() {
+              next();
+            });
+            stream.on('error', function(err) {
+              next(err);
+            });
+          });
+        } else {
+          next();
+        }
+      });
+    } else {
+      next();
+    }
+  });
+
+  schema.pre('remove', function(next) {
+    if(!this.path) {
+      return next();
+    }
+    this.collection.remove({ path : { '$regex' : '^' + this.path + '.' } }, next);
+  });
+
+  schema.method('getChildren', function(recursive, cb) {
+    if(typeof(recursive) === "function") {
+      cb = recursive;
+      recursive = false;
+    }
+    var filter = recursive ? { path : { $regex : '^' + this.path + '.' } } : { parent : this._id };
+    return this.model(this.constructor.modelName).find(filter, cb);
+  });
+
+  schema.method('getParent', function(cb) {
+    return this.model(this.constructor.modelName).findOne({ _id : this.parent }, cb);
+  });
+
+  schema.method('getAnsestors', function(cb) {
+    if(this.path) {
+      var ids = this.path.split(".");
+      ids.pop();
+    } else {
+      var ids = [];
+    }
+    var filter = { _id : { $in : ids } };
+    return this.model(this.constructor.modelName).find(filter, cb);
+  });
+
+  schema.virtual('level').get(function() {
+    return this.path ? this.path.split(".").length : 0;
+  });
+}

package.json

@@ -0,0 +1,15 @@
+{
+  "author": "Brian Kirchoff <briankircho@gmail.com>",
+  "name": "mongoose-tree",
+  "description": "Materialized path hierarchy for mongoose",
+  "version": "0.0.1",
+  "engine": "node >= 0.8.0",
+  "dependencies": {
+    "mongoose": "~2.7.1"
+  },
+  "devDependencies": {
+    "async": "~0.1.22",
+    "should": "~1.0.0",
+    "underscore": "~1.3.3"
+  }
+}