Find, modificate and remove recursive embedded-document mongoosejs

Question

Find, modificate and remove recursive embedded-document mongoosejs

I use the description of the scheme from the example.

Comment.add({
    title     : { type: String, index: true }
  , date      : Date
  , body      : String
  , comments  : [Comment]
});

var BlogPost = new Schema({
    title     : { type: String, index: true }
  , slug      : { type: String, lowercase: true, trim: true }
  , date      : Date
  , buf       : Buffer
  , comments  : [Comment]
  , creator   : Schema.ObjectId
});

I have several levels of nesting in comments. how to find the right comment at any level of nesting and make any action with it (deleting editing or adding a new nested comment) I tried to make recursion for the search but you could not save or delete the comments

BlogPost.methods.findComment = function (id, callback) {

  var curentComment = this.comments;
  var findComment = null;
  var recursiveFindComment = function(comment){
      for(i=0;i<comment.length;i++){
          if(findComment){
              break;
          }
          if(comment[i]._id == id){
              findComment  = comment[i];
              break;    
          }else if(comment[i].comments.length>0){
              findComment = recursiveFindComment(comment[i].comments)
          }
      }
      return findComment;

  }

  if(curentComment.id(id)){
     callback(curentComment);  
  }else{
     callback(recursiveFindComment(curentComment, null)) 
  }
}

node.js
mongoose

Answer 1

You might want to look at using trees in MongoDb ( http://www.mongodb.org/display/DOCS/Trees+in+MongoDB ). There are a bunch of different methods to help with the recursive nature of your schema.

> t = db.tree
test.tree

> // get entire tree -- we use sort() to make the order nice
> t.find().sort({path:1})
{ "_id" : "a", "path" : "a," }
{ "_id" : "b", "path" : "a,b," }
{ "_id" : "c", "path" : "a,b,c," }
{ "_id" : "d", "path" : "a,b,d," }
{ "_id" : "g", "path" : "a,b,g," }
{ "_id" : "e", "path" : "a,e," }
{ "_id" : "f", "path" : "a,e,f," }
{ "_id" : "g", "path" : "a,b,g," }

> t.ensureIndex( {path:1} )

> // find the node 'b' and all its descendents:
> t.find( { path : /^a,b,/ } )
{ "_id" : "b", "path" : "a,b," }
{ "_id" : "c", "path" : "a,b,c," }
{ "_id" : "d", "path" : "a,b,d," }
{ "_id" : "g", "path" : "a,b,g," }

> // find the node 'b' and its descendents, where path to 'b' is not already known:
> nodeb = t.findOne( { _id : "b" } )
{ "_id" : "b", "path" : "a,b," }
> t.find( { path : new RegExp("^" + nodeb.path) } )
{ "_id" : "b", "path" : "a,b," }
{ "_id" : "c", "path" : "a,b,c," }
{ "_id" : "d", "path" : "a,b,d," }
{ "_id" : "g", "path" : "a,b,g," }