CODEWITHSUNDEEP
javascriptnode.jsmongodbmongooseasync.js
metaphor
metaphor

Reputation: 470

Populate Query Options with Async Waterfall

I'm trying mongoose populate query options but i don't know why the query options doesn't work.

I have user schema:

const mongoose = require('mongoose');
const Schema   = mongoose.Schema;

const UserSchema = new Schema(
  {
    username: { type: String, required: true },
    email: { type: String },
    name: { type: String },
    address: { type: String }
  },
  { timestamps: true }
);
module.exports = mongoose.model('User', UserSchema);

and feed schema:

const mongoose = require('mongoose');
const Schema   = mongoose.Schema;

const FeedSchema = new Schema(
  {
    user: { type: Schema.ObjectId, ref: 'User' },
    notes: { type: String, required: true },
    trx_date: { type: Date },
    status: { type: Boolean, Default: true }
  },
  { timestamps: true }
);

FeedSchema.set('toObject', { getters: true  });

module.exports = mongoose.model('Feed', FeedSchema);

I want to find all feed by user id, i used async waterfall like the following code:

async.waterfall([
  function(callback) {
    User
      .findOne({ 'username': username })
      .exec((err, result) => {
        if (result) {
          callback(null, result);
        } else {
          callback(err);
        }
      });
  },

  function(userid, callback) {

    // find user's feed
    Feed
      .find({})
      // .populate('user', {_id: userid._id})  <== this one also doesn't work
      .populate({
        path: 'user',
        match: { '_id': { $in: userid._id } }
      })
      .exec(callback);
  }
], function(err, docs) {
  if (err) {
    return next(err);
  }

  console.log(docs);
});

With above code, i got all feeds, and it seems like the query option do not work at all, did i doing it wrong ?

Any help would be appreciate.

Upvotes: 2

Views: 561

Answers (1)

Neil Lunn
Neil Lunn

Reputation: 151092

Not sure why you are looking to match "after" population when the value of _id is what is already stored in the "user" property "before" you even populate.

As such it's really just a simple "query" condition to .find() instead:

async.waterfall([
  (callback) =>
    User.findOne({ 'username': username }).exec(callback),

  (user, callback) => {
    if (!user) callback(new Error('not found'));  // throw here if not found
    // find user's feed
    Feed
      .find({ user: user._id })
      .populate('user')
      .exec(callback);
  }
], function(err, docs) {
  if (err) {
    return next(err);
  }

  console.log(docs);
});

Keeping in mind of course that the .findOne() is returning the whole document, so you just want the _id property in the new query. Also note that the "juggling" in the initial waterfall function is not necessary. If there is an error then it will "fast fail" to the end callback, or otherwise pass through the result where it is not. Delate "not found" to the next method instead.

Of course this really is not necessary since "Promises" have been around for some time and you really should be using them:

User.findOne({ "username": username })
 .then( user => Feed.find({ "user": user._id }).populate('user') )
 .then( feeds => /* do something */ )
 .catch(err => /* do something with any error */)

Or indeed using $lookup where you MongoDB supports it:

User.aggregate([
  { "$match": { "username": username } },
  { "$lookup": {
    "from": Feed.collection.name,
    "localField": "_id",
    "foreignField": "user",
    "as": "feeds"
  }}
]).then( user => /* User with feeds in array /* )

Which is a bit different in output, and you could actually change it to look the same with a bit of manipulation, but this should give you the general idea.

Importantly is generally better to let the server do the join rather than issue multiple requests, which increases latency at the very least.

Upvotes: 2

Related Questions