Documents in ES6

    Asynchronous document functions return promises, and so are compatible with the ES6 yield keyword and libraries like co.

    Note that the yield keyword is currently only supported in NodeJS 0.11.x with the --harmony flag.

    validate() integrates with co and the yield keyword

    2.     co(function*() {
    3.       var schema = null;
    4.       var called = false;
    5.       var shouldSucceed = true;
    6.       var error;
    8.       var validate = {
    9.         validator: function() {
    10.           called = true;
    11.           return shouldSucceed;
    12.         },
    13.         message: 'BAM'
    14.       };
    16.       schema = new Schema({
    17.         eggs: {type: String, required: true, validate: validate},
    18.         bacon: {type: Boolean, required: true}
    19.       });
    21.       var M = db.model('validateSchema', schema, getCollectionName());
    22.       var m = new M({eggs: 'Sunny side up', bacon: false});
    24.       try {
    25.         yield m.validate();
    26.       } catch (e) {
    27.         error = e;
    28.       }
    30.       assert.ok(!error);
    31.       assert.equal(called, true);
    32.       called = false;
    34.       // The validator function above should now fail
    35.       shouldSucceed = false;
    36.       try {
    37.         yield m.validate();
    38.       } catch (e) {
    39.         error = e;
    40.       }
    42.       assert.ok(error);
    43.       assert.ok(error instanceof ValidationError);
    45.       done();
    46.     })();

    save() integrates with co and the yield keyword

    2.     co(function*() {
    3.       var error;
    4.       var schema = new Schema({
    5.         description: {type: String, required: true}
    6.       });
    8.       var Breakfast = db.model('breakfast', schema, getCollectionName());
    10.       var goodBreakfast = new Breakfast({description: 'eggs & bacon'});
    12.       try {
    13.         yield goodBreakfast.save();
    14.       } catch (e) {
    15.         error = e;
    16.       }
    18.       assert.ifError(error);
    19.       var result;
    20.       try {
    21.         result = yield Breakfast.findOne().exec();
    22.       } catch (e) {
    23.         error = e;
    24.       }
    25.       assert.ifError(error);
    26.       assert.equal(result.description, 'eggs & bacon');
    28.       // Should cause a validation error because `description` is required
    29.       var badBreakfast = new Breakfast({});
    30.       try {
    31.         yield badBreakfast.save();
    32.       } catch (e) {
    33.         error = e;
    34.       }
    36.       assert.ok(error);
    37.       assert.ok(error instanceof ValidationError);
    39.       done();
    40.     })();

    populate() requires execPopulate() to work with the yield keyword

    2.     /**
    3.      *  Because the `populate()` function supports chaining, it's difficult
    4.      *  to determine when the chain is 'done'. Therefore, you need to call
    5.      *  `execPopulate()` to use `populate()` with `yield`.
    6.      */
    7.     co(function*() {
    8.       var error;
    9.       var breakfastCollectionName = getCollectionName();
    10.       var foodCollectionName = getCollectionName();
    11.       var breakfastSchema = new Schema({
    12.         foods: [{type: mongoose.Schema.ObjectId, ref: foodCollectionName}]
    13.       });
    15.       var foodSchema = new Schema({
    16.         name: String
    17.       });
    19.       var Food = db.model(foodCollectionName, foodSchema, foodCollectionName);
    20.       var Breakfast = db.model(breakfastCollectionName, breakfastSchema, breakfastCollectionName);
    22.       var bacon = new Food({name: 'bacon'});
    23.       var eggs = new Food({name: 'eggs'});
    24.       var goodBreakfast = new Breakfast({foods: [bacon, eggs]});
    26.       try {
    27.         yield [bacon.save(), eggs.save(), goodBreakfast.save()];
    28.       } catch (e) {
    29.         error = e;
    30.       }
    32.       var result;
    33.       try {
    34.         result = yield Breakfast.findOne().exec();
    35.       } catch (e) {
    36.         error = e;
    37.       }
    38.       assert.ifError(error);
    39.       assert.equal(result.foods.length, 2);
    41.       try {
    42.         result = yield result.populate('foods').execPopulate();
    43.       } catch (e) {
    44.         error = e;
    45.       }
    46.       assert.ifError(error);
    47.       assert.equal(result.foods.length, 2);
    48.       assert.equal(result.foods[0].name, 'bacon');
    49.       assert.equal(result.foods[1].name, 'eggs');
    51.       done();
    52.     })();

    update() works with co and yield

    2.     co(function*() {
    3.       var schema = new Schema({
    4.         steak: String,
    5.         eggs: String
    6.       });
    8.       var Breakfast = db.model('breakfast', schema, getCollectionName());
    10.       var breakfast = new Breakfast({});
    11.       var error;
    13.       try {
    14.         yield breakfast.update({steak: 'Ribeye', eggs: 'Scrambled'}, {upsert: true}).exec();
    15.       } catch (e) {
    16.         error = e;
    17.       }
    19.       assert.ifError(error);
    20.       var result;
    21.       try {
    22.         result = yield Breakfast.findOne().exec();
    23.       } catch (e) {
    24.         error = e;
    25.       }
    26.       assert.ifError(error);
    27.       assert.equal(breakfast._id.toString(), result._id.toString());
    28.       assert.equal(result.steak, 'Ribeye');
    29.       assert.equal(result.eggs, 'Scrambled');
    30.       done();
    31.     })();

    Queries in ES6

    Mongoose queries’ .exec() function returns a promise, and so its compatible with the ES6 yield keyword and libraries like co.

    Note that the yield keyword is currently only supported in NodeJS 0.11.x with the --harmony flag.

    exec() integrates with co and the yield keyword

    2.     co(function*() {
    3.       var schema = new Schema({
    4.         eggs: {type: Number, required: true},
    5.         bacon: {type: Number, required: true}
    6.       });
    8.       var Breakfast = db.model('BreakfastHarmony', schema, getCollectionName());
    10.       try {
    11.         yield Breakfast.create(
    12.           {eggs: 4, bacon: 2},
    13.           {eggs: 3, bacon: 3},
    14.           {eggs: 2, bacon: 4});
    15.       } catch (e) {
    16.         return done(e);
    17.       }
    19.       var result;
    20.       try {
    21.         result = yield Breakfast.findOne({eggs: 4}).exec();
    22.       } catch (e) {
    23.         return done(e);
    24.       }
    26.       assert.equal(result.bacon, 2);
    28.       var results;
    29.       try {
    30.         results = yield Breakfast.find({eggs: {$gt: 2}}).sort({bacon: 1}).exec();
    31.       } catch (e) {
    32.         return done(e);
    33.       }
    35.       assert.equal(results.length, 2);
    36.       assert.equal(results[0].bacon, 2);
    37.       assert.equal(results[1].bacon, 3);
    39.       var count;
    40.       try {
    41.         count = yield Breakfast.count({eggs: {$gt: 2}}).exec();
    42.       } catch (e) {
    43.         return done(e);
    44.       }
    46.       assert.equal(count, 2);
    48.       done();
    49.     })();

    can call populate() with exec()

    2.     co(function*() {
    3.       var bookSchema = new Schema({
    4.         author: {type: mongoose.Schema.ObjectId, ref: 'AuthorHarmony'},
    5.         title: String
    6.       });
    8.       var authorSchema = new Schema({
    9.         name: String
    10.       });
    12.       var Book = db.model('BookHarmony', bookSchema, getCollectionName());
    13.       var Author = db.model('AuthorHarmony', authorSchema, getCollectionName());
    15.       try {
    16.         var hugo = yield Author.create({name: 'Victor Hugo'});
    17.         yield Book.create({author: hugo._id, title: 'Les Miserables'});
    18.       } catch (e) {
    19.         return done(e);
    20.       }
    22.       var result;
    23.       try {
    24.         result = yield Book.findOne({title: 'Les Miserables'}).populate('author').exec();
    25.       } catch (e) {
    26.         return done(e);
    27.       }
    29.       assert.equal(result.author.name, 'Victor Hugo');
    31.       done();
    32.     })();

    Models in ES6

    Asynchronous functions on Model return promises, and so are compatible with the ES6 yield keyword and libraries like co.

    Note that the functions find(), findOne(), findById(), count(), findOneAndUpdate(), remove(), distinct(), findByIdAndUpdate(), findOneAndRemove(), update(), and findByIdAndRemove() return Query objects, and so you need to use .exec() to use these functions with yield as described above.

    create() integrates with co and the yield keyword

    2.     co(function * () {
    3.       var schema = new Schema({
    4.         eggs: {type: String, required: true},
    5.         bacon: {type: Boolean, required: true}
    6.       });
    8.       var M = db.model('harmonyCreate', schema, getCollectionName());
    10.       var results;
    11.       try {
    12.         results = yield M.create([
    13.           {eggs: 'sunny-side up', bacon: false},
    14.           {eggs: 'scrambled', bacon: true}]);
    15.       } catch (e) {
    16.         return done(e);
    17.       }
    19.       assert.equal(results.length, 2);
    20.       assert.equal(results[0].eggs, 'sunny-side up');
    21.       assert.equal(results[1].eggs, 'scrambled');
    23.       done();
    24.     })();

    aggregate() integrates with co and the yield keyword

    2.     co(function*() {
    3.       var schema = new Schema({
    4.         eggs: {type: String, required: true},
    5.         bacon: {type: Boolean, required: true}
    6.       });
    8.       var M = db.model('harmonyAggregate', schema, getCollectionName());
    10.       try {
    11.         yield M.create([
    12.           {eggs: 'sunny-side up', bacon: false},
    13.           {eggs: 'scrambled', bacon: true}]);
    14.       } catch (e) {
    15.         return done(e);
    16.       }
    18.       var results;
    19.       try {
    20.         results = yield M.aggregate([
    21.           {$group: {_id: '$bacon', eggs: {$first: '$eggs'}}},
    22.           {$sort: {_id: 1}}
    23.         ]).exec();
    24.       } catch (e) {
    25.         return done(e);
    26.       }
    28.       assert.equal(results.length, 2);
    29.       assert.equal(results[0]._id, false);
    30.       assert.equal(results[0].eggs, 'sunny-side up');
    31.       assert.equal(results[1]._id, true);
    32.       assert.equal(results[1].eggs, 'scrambled');
    34.       done();
    35.     })();

    mapReduce() can also be used with co and yield

    2.     co(function*() {
    3.       var schema = new Schema({
    4.         eggs: {type: String, required: true},
    5.         bacon: {type: Boolean, required: true}
    6.       });
    8.       var M = db.model('harmonyMapreduce', schema, getCollectionName());
    10.       try {
    11.         yield M.create([
    12.           {eggs: 'sunny-side up', bacon: false},
    13.           {eggs: 'sunny-side up', bacon: true},
    14.           {eggs: 'scrambled', bacon: true}]);
    15.       } catch (e) {
    16.         return done(e);
    17.       }
    19.       var results;
    20.       try {
    21.         results = yield M.mapReduce({
    22.           map: function() { emit(this.eggs, 1); },
    23.           reduce: function(k, vals) { return vals.length; }
    24.         });
    25.       } catch (e) {
    26.         return done(e);
    27.       }
    29.       assert.equal(results.length, 2);
    30.       assert.ok(results[0]._id === 'sunny-side up' || results[1]._id === 'sunny-side up');
    31.       assert.ok(results[0]._id === 'scrambled' || results[1]._id === 'scrambled');
    33.       done();
    34.     })();