Updated mongoose

node_modules/mongoose/examples/population/population-across-three-collections.js

@@ -0,0 +1,135 @@
+
+var assert = require('assert');
+var mongoose = require('../../lib');
+var Schema = mongoose.Schema;
+var ObjectId = mongoose.Types.ObjectId;
+
+/**
+ * Connect to the db
+ */
+
+var dbname = 'testing_populateAdInfinitum_' + require('../../lib/utils').random();
+mongoose.connect('localhost', dbname);
+mongoose.connection.on('error', function() {
+  console.error('connection error', arguments);
+});
+
+/**
+ * Schemas
+ */
+
+var user = new Schema({
+  name: String,
+  friends: [{
+    type: Schema.ObjectId,
+    ref: 'User'
+  }]
+});
+var User = mongoose.model('User', user);
+
+var blogpost = Schema({
+  title: String,
+  tags: [String],
+  author: {
+    type: Schema.ObjectId,
+    ref: 'User'
+  }
+});
+var BlogPost = mongoose.model('BlogPost', blogpost);
+
+/**
+ * example
+ */
+
+mongoose.connection.on('open', function() {
+
+  /**
+   * Generate data
+   */
+
+  var userIds = [new ObjectId, new ObjectId, new ObjectId, new ObjectId];
+  var users = [];
+
+  users.push({
+    _id: userIds[0],
+    name: 'mary',
+    friends: [userIds[1], userIds[2], userIds[3]]
+  });
+  users.push({
+    _id: userIds[1],
+    name: 'bob',
+    friends: [userIds[0], userIds[2], userIds[3]]
+  });
+  users.push({
+    _id: userIds[2],
+    name: 'joe',
+    friends: [userIds[0], userIds[1], userIds[3]]
+  });
+  users.push({
+    _id: userIds[3],
+    name: 'sally',
+    friends: [userIds[0], userIds[1], userIds[2]]
+  });
+
+  User.create(users, function(err) {
+    assert.ifError(err);
+
+    var blogposts = [];
+    blogposts.push({
+      title: 'blog 1',
+      tags: ['fun', 'cool'],
+      author: userIds[3]
+    });
+    blogposts.push({
+      title: 'blog 2',
+      tags: ['cool'],
+      author: userIds[1]
+    });
+    blogposts.push({
+      title: 'blog 3',
+      tags: ['fun', 'odd'],
+      author: userIds[2]
+    });
+
+    BlogPost.create(blogposts, function(err) {
+      assert.ifError(err);
+
+      /**
+       * Population
+       */
+
+      BlogPost
+      .find({ tags: 'fun' })
+      .lean()
+      .populate('author')
+      .exec(function(err, docs) {
+        assert.ifError(err);
+
+        /**
+         * Populate the populated documents
+         */
+
+        var opts = {
+          path: 'author.friends',
+          select: 'name',
+          options: { limit: 2 }
+        };
+
+        BlogPost.populate(docs, opts, function(err, docs) {
+          assert.ifError(err);
+          console.log('populated');
+          var s = require('util').inspect(docs, { depth: null });
+          console.log(s);
+          done();
+        });
+      });
+    });
+  });
+});
+
+function done(err) {
+  if (err) console.error(err.stack);
+  mongoose.connection.db.dropDatabase(function() {
+    mongoose.connection.close();
+  });
+}

node_modules/mongoose/examples/population/population-basic.js

@@ -0,0 +1,103 @@
+
+var mongoose = require('../../lib');
+var Schema = mongoose.Schema;
+
+console.log('Running mongoose version %s', mongoose.version);
+
+/**
+ * Console schema
+ */
+
+var consoleSchema = Schema({
+  name: String,
+  manufacturer: String,
+  released: Date
+});
+var Console = mongoose.model('Console', consoleSchema);
+
+/**
+ * Game schema
+ */
+
+var gameSchema = Schema({
+  name: String,
+  developer: String,
+  released: Date,
+  consoles: [{
+    type: Schema.Types.ObjectId,
+    ref: 'Console'
+  }]
+});
+var Game = mongoose.model('Game', gameSchema);
+
+/**
+ * Connect to the console database on localhost with
+ * the default port (27017)
+ */
+
+mongoose.connect('mongodb://localhost/console', function(err) {
+  // if we failed to connect, abort
+  if (err) throw err;
+
+  // we connected ok
+  createData();
+});
+
+/**
+ * Data generation
+ */
+
+function createData() {
+  Console.create(
+    {
+      name: 'Nintendo 64',
+      manufacturer: 'Nintendo',
+      released: 'September 29, 1996'
+    },
+    function(err, nintendo64) {
+      if (err) return done(err);
+
+      Game.create({
+        name: 'Legend of Zelda: Ocarina of Time',
+        developer: 'Nintendo',
+        released: new Date('November 21, 1998'),
+        consoles: [nintendo64]
+      },
+      function(err) {
+        if (err) return done(err);
+        example();
+      });
+    }
+  );
+}
+
+/**
+ * Population
+ */
+
+function example() {
+  Game
+  .findOne({ name: /^Legend of Zelda/ })
+  .populate('consoles')
+  .exec(function(err, ocinara) {
+    if (err) return done(err);
+
+    console.log(
+      '"%s" was released for the %s on %s',
+      ocinara.name,
+      ocinara.consoles[0].name,
+      ocinara.released.toLocaleDateString()
+    );
+
+    done();
+  });
+}
+
+function done(err) {
+  if (err) console.error(err);
+  Console.remove(function() {
+    Game.remove(function() {
+      mongoose.disconnect();
+    });
+  });
+}

node_modules/mongoose/examples/population/population-of-existing-doc.js

@@ -0,0 +1,109 @@
+
+var mongoose = require('../../lib');
+var Schema = mongoose.Schema;
+
+console.log('Running mongoose version %s', mongoose.version);
+
+/**
+ * Console schema
+ */
+
+var consoleSchema = Schema({
+  name: String,
+  manufacturer: String,
+  released: Date
+});
+var Console = mongoose.model('Console', consoleSchema);
+
+/**
+ * Game schema
+ */
+
+var gameSchema = Schema({
+  name: String,
+  developer: String,
+  released: Date,
+  consoles: [{
+    type: Schema.Types.ObjectId,
+    ref: 'Console'
+  }]
+});
+var Game = mongoose.model('Game', gameSchema);
+
+/**
+ * Connect to the console database on localhost with
+ * the default port (27017)
+ */
+
+mongoose.connect('mongodb://localhost/console', function(err) {
+  // if we failed to connect, abort
+  if (err) throw err;
+
+  // we connected ok
+  createData();
+});
+
+/**
+ * Data generation
+ */
+
+function createData() {
+  Console.create(
+    {
+      name: 'Nintendo 64',
+      manufacturer: 'Nintendo',
+      released: 'September 29, 1996'
+    },
+    function(err, nintendo64) {
+      if (err) return done(err);
+
+      Game.create({
+        name: 'Legend of Zelda: Ocarina of Time',
+        developer: 'Nintendo',
+        released: new Date('November 21, 1998'),
+        consoles: [nintendo64]
+      },
+      function(err) {
+        if (err) return done(err);
+        example();
+      });
+    }
+  );
+}
+
+/**
+ * Population
+ */
+
+function example() {
+  Game
+  .findOne({ name: /^Legend of Zelda/ })
+  .exec(function(err, ocinara) {
+    if (err) return done(err);
+
+    console.log('"%s" console _id: %s', ocinara.name, ocinara.consoles[0]);
+
+    // population of existing document
+    ocinara.populate('consoles', function(err) {
+      if (err) return done(err);
+
+      console.log(
+        '"%s" was released for the %s on %s',
+        ocinara.name,
+        ocinara.consoles[0].name,
+        ocinara.released.toLocaleDateString()
+      );
+
+      done();
+    });
+  });
+}
+
+function done(err) {
+  if (err) console.error(err);
+  Console.remove(function() {
+    Game.remove(function() {
+      mongoose.disconnect();
+    });
+  });
+}

node_modules/mongoose/examples/population/population-of-multiple-existing-docs.js

@@ -0,0 +1,124 @@
+
+var mongoose = require('../../lib');
+var Schema = mongoose.Schema;
+
+console.log('Running mongoose version %s', mongoose.version);
+
+/**
+ * Console schema
+ */
+
+var consoleSchema = Schema({
+  name: String,
+  manufacturer: String,
+  released: Date
+});
+var Console = mongoose.model('Console', consoleSchema);
+
+/**
+ * Game schema
+ */
+
+var gameSchema = Schema({
+  name: String,
+  developer: String,
+  released: Date,
+  consoles: [{
+    type: Schema.Types.ObjectId,
+    ref: 'Console'
+  }]
+});
+var Game = mongoose.model('Game', gameSchema);
+
+/**
+ * Connect to the console database on localhost with
+ * the default port (27017)
+ */
+
+mongoose.connect('mongodb://localhost/console', function(err) {
+  // if we failed to connect, abort
+  if (err) throw err;
+
+  // we connected ok
+  createData();
+});
+
+/**
+ * Data generation
+ */
+
+function createData() {
+  Console.create(
+    {
+      name: 'Nintendo 64',
+      manufacturer: 'Nintendo',
+      released: 'September 29, 1996'
+    },
+    {
+      name: 'Super Nintendo',
+      manufacturer: 'Nintendo',
+      released: 'August 23, 1991'
+    },
+    function(err, nintendo64, superNintendo) {
+      if (err) return done(err);
+
+      Game.create(
+        {
+          name: 'Legend of Zelda: Ocarina of Time',
+          developer: 'Nintendo',
+          released: new Date('November 21, 1998'),
+          consoles: [nintendo64]
+        },
+        {
+          name: 'Mario Kart',
+          developer: 'Nintendo',
+          released: 'September 1, 1992',
+          consoles: [superNintendo]
+        },
+        function(err) {
+          if (err) return done(err);
+          example();
+        }
+      );
+    }
+  );
+}
+
+/**
+ * Population
+ */
+
+function example() {
+  Game
+  .find({})
+  .exec(function(err, games) {
+    if (err) return done(err);
+
+    console.log('found %d games', games.length);
+
+    var options = { path: 'consoles', select: 'name released -_id' };
+    Game.populate(games, options, function(err, games) {
+      if (err) return done(err);
+
+      games.forEach(function(game) {
+        console.log(
+          '"%s" was released for the %s on %s',
+          game.name,
+          game.consoles[0].name,
+          game.released.toLocaleDateString()
+        );
+      });
+
+      done();
+    });
+  });
+}
+
+function done(err) {
+  if (err) console.error(err);
+  Console.remove(function() {
+    Game.remove(function() {
+      mongoose.disconnect();
+    });
+  });
+}

node_modules/mongoose/examples/population/population-options.js

@@ -0,0 +1,138 @@
+
+var mongoose = require('../../lib');
+var Schema = mongoose.Schema;
+
+console.log('Running mongoose version %s', mongoose.version);
+
+/**
+ * Console schema
+ */
+
+var consoleSchema = Schema({
+  name: String,
+  manufacturer: String,
+  released: Date
+});
+var Console = mongoose.model('Console', consoleSchema);
+
+/**
+ * Game schema
+ */
+
+var gameSchema = Schema({
+  name: String,
+  developer: String,
+  released: Date,
+  consoles: [{
+    type: Schema.Types.ObjectId,
+    ref: 'Console'
+  }]
+});
+var Game = mongoose.model('Game', gameSchema);
+
+/**
+ * Connect to the console database on localhost with
+ * the default port (27017)
+ */
+
+mongoose.connect('mongodb://localhost/console', function(err) {
+  // if we failed to connect, abort
+  if (err) throw err;
+
+  // we connected ok
+  createData();
+});
+
+/**
+ * Data generation
+ */
+
+function createData() {
+  Console.create(
+    {
+      name: 'Nintendo 64',
+      manufacturer: 'Nintendo',
+      released: 'September 29, 1996'
+    },
+    {
+      name: 'Super Nintendo',
+      manufacturer: 'Nintendo',
+      released: 'August 23, 1991'
+    },
+    {
+      name: 'XBOX 360',
+      manufacturer: 'Microsoft',
+      released: 'November 22, 2005'
+    },
+    function(err, nintendo64, superNintendo, xbox360) {
+      if (err) return done(err);
+
+      Game.create(
+        {
+          name: 'Legend of Zelda: Ocarina of Time',
+          developer: 'Nintendo',
+          released: new Date('November 21, 1998'),
+          consoles: [nintendo64]
+        },
+        {
+          name: 'Mario Kart',
+          developer: 'Nintendo',
+          released: 'September 1, 1992',
+          consoles: [superNintendo]
+        },
+        {
+          name: 'Perfect Dark Zero',
+          developer: 'Rare',
+          released: 'November 17, 2005',
+          consoles: [xbox360]
+        },
+        function(err) {
+          if (err) return done(err);
+          example();
+        }
+      );
+    }
+  );
+}
+
+/**
+ * Population
+ */
+
+function example() {
+  Game
+  .find({})
+  .populate({
+    path: 'consoles',
+    match: { manufacturer: 'Nintendo' },
+    select: 'name',
+    options: { comment: 'population' }
+  })
+  .exec(function(err, games) {
+    if (err) return done(err);
+
+    games.forEach(function(game) {
+      console.log(
+        '"%s" was released for the %s on %s',
+        game.name,
+        game.consoles.length ? game.consoles[0].name : '??',
+        game.released.toLocaleDateString()
+      );
+    });
+
+    return done();
+  });
+}
+
+/**
+ * Clean up
+ */
+
+function done(err) {
+  if (err) console.error(err);
+  Console.remove(function() {
+    Game.remove(function() {
+      mongoose.disconnect();
+    });
+  });
+}

node_modules/mongoose/examples/population/population-plain-objects.js

@@ -0,0 +1,106 @@
+
+var mongoose = require('../../lib');
+var Schema = mongoose.Schema;
+
+console.log('Running mongoose version %s', mongoose.version);
+
+/**
+ * Console schema
+ */
+
+var consoleSchema = Schema({
+  name: String,
+  manufacturer: String,
+  released: Date
+});
+var Console = mongoose.model('Console', consoleSchema);
+
+/**
+ * Game schema
+ */
+
+var gameSchema = Schema({
+  name: String,
+  developer: String,
+  released: Date,
+  consoles: [{
+    type: Schema.Types.ObjectId,
+    ref: 'Console'
+  }]
+});
+var Game = mongoose.model('Game', gameSchema);
+
+/**
+ * Connect to the console database on localhost with
+ * the default port (27017)
+ */
+
+mongoose.connect('mongodb://localhost/console', function(err) {
+  // if we failed to connect, abort
+  if (err) throw err;
+
+  // we connected ok
+  createData();
+});
+
+/**
+ * Data generation
+ */
+
+function createData() {
+  Console.create(
+    {
+      name: 'Nintendo 64',
+      manufacturer: 'Nintendo',
+      released: 'September 29, 1996'
+    },
+    function(err, nintendo64) {
+      if (err) return done(err);
+
+      Game.create(
+        {
+          name: 'Legend of Zelda: Ocarina of Time',
+          developer: 'Nintendo',
+          released: new Date('November 21, 1998'),
+          consoles: [nintendo64]
+        },
+        function(err) {
+          if (err) return done(err);
+          example();
+        }
+      );
+    }
+  );
+}
+
+/**
+ * Population
+ */
+
+function example() {
+  Game
+  .findOne({ name: /^Legend of Zelda/ })
+  .populate('consoles')
+  .lean() // just return plain objects, not documents wrapped by mongoose
+  .exec(function(err, ocinara) {
+    if (err) return done(err);
+
+    console.log(
+      '"%s" was released for the %s on %s',
+      ocinara.name,
+      ocinara.consoles[0].name,
+      ocinara.released.toLocaleDateString()
+    );
+
+    done();
+  });
+}
+
+function done(err) {
+  if (err) console.error(err);
+  Console.remove(function() {
+    Game.remove(function() {
+      mongoose.disconnect();
+    });
+  });
+}