mongodb 2.1.0-alpha → 2.1.2

package/lib/collection.js

@@ -17,6 +17,7 @@ var checkCollectionName = require('./utils').checkCollectionName
   , ReadPreference = require('./read_preference')
   , CoreReadPreference = require('mongodb-core').ReadPreference
   , CommandCursor = require('./command_cursor')
+  , Define = require('./metadata')
   , Cursor = require('./cursor')
   , unordered = require('./bulk/unordered')
   , ordered = require('./bulk/ordered');
@@ -24,7 +25,7 @@ var checkCollectionName = require('./utils').checkCollectionName
 /**
  * @fileOverview The **Collection** class is an internal class that embodies a MongoDB collection
  * allowing for insert/update/remove/find and other command operation on that MongoDB collection.
- * 
+ *
  * **COLLECTION Cannot directly be instantiated**
  * @example
  * var MongoClient = require('mongodb').MongoClient,
@@ -50,10 +51,11 @@ var checkCollectionName = require('./utils').checkCollectionName
  * @property {string} collectionName Get the collection name.
  * @property {string} namespace Get the full collection namespace.
  * @property {object} writeConcern The current write concern values.
+ * @property {object} readConcern The current read concern values.
  * @property {object} hint Get current index hint for collection.
  * @return {Collection} a Collection instance.
  */
-var Collection = function(db, topology, dbName, name, pkFactory, options) {  
+var Collection = function(db, topology, dbName, name, pkFactory, options) {
   checkCollectionName(name);
   var self = this;
   // Unpack variables
@@ -117,9 +119,13 @@ var Collection = function(db, topology, dbName, name, pkFactory, options) {
     , name: name
     // Promise library
     , promiseLibrary: promiseLibrary
+    // Read Concern
+    , readConcern: options.readConcern
   }
 }
 
+var define = Collection.define = new Define('Collection', Collection, false);
+
 Object.defineProperty(Collection.prototype, 'collectionName', {
   enumerable: true, get: function() { return this.s.name; }
 });
@@ -128,9 +134,13 @@ Object.defineProperty(Collection.prototype, 'namespace', {
   enumerable: true, get: function() { return this.s.namespace; }
 });
 
+Object.defineProperty(Collection.prototype, 'readConcern', {
+  enumerable: true, get: function() { return this.s.readConcern || {level: 'local'}; }
+});
+
 Object.defineProperty(Collection.prototype, 'writeConcern', {
   enumerable:true,
-  get: function() { 
+  get: function() {
     var ops = {};
     if(this.s.options.w != null) ops.w = this.s.options.w;
     if(this.s.options.j != null) ops.j = this.s.options.j;
@@ -172,7 +182,7 @@ Collection.prototype.find = function() {
     options = args[0];
   }
 
-  if(len === 2 && !Array.isArray(fields)) {
+  if(len === 2 && fields !== undefined && !Array.isArray(fields)) {
     var fieldKeys = Object.keys(fields);
     var is_option = false;
 
@@ -277,7 +287,7 @@ Collection.prototype.find = function() {
 
   // Ensure the query is an object
   if(selector != null && typeof selector != 'object') {
-    throw new MongoError("query selector must be an object");
+    throw MongoError.create({message: "query selector must be an object", driver:true });
   }
 
   // Build the find command
@@ -292,7 +302,7 @@ Collection.prototype.find = function() {
   if(typeof newOptions.awaitdata == 'boolean')  {
     newOptions.awaitData = newOptions.awaitdata
   };
-  
+
   // Translate to new command option noCursorTimeout
   if(typeof newOptions.timeout == 'boolean') newOptions.noCursorTimeout = newOptions.timeout;
 
@@ -332,16 +342,26 @@ Collection.prototype.find = function() {
   if(newOptions.raw == null && this.s.raw) newOptions.raw = this.s.raw;
 
   // Sort options
-  if(findCommand.sort) 
+  if(findCommand.sort)
     findCommand.sort = formattedOrderClause(findCommand.sort);
 
+  // Set the readConcern
+  if(this.s.readConcern) {
+    findCommand.readConcern = this.s.readConcern;
+  }
+
   // Create the cursor
   if(typeof callback == 'function') return handleCallback(callback, null, this.s.topology.cursor(this.s.namespace, findCommand, newOptions));
   return this.s.topology.cursor(this.s.namespace, findCommand, newOptions);
 }
 
+define.classMethod('find', {callback: false, promise:false, returns: [Cursor]});
+
 /**
- * Inserts a single document into MongoDB.
+ * Inserts a single document into MongoDB. If documents passed in do not contain the **_id** field, 
+ * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
+ * can be overridden by setting the **forceServerObjectId** flag.
+ *
  * @method
  * @param {object} doc Document to insert.
  * @param {object} [options=null] Optional settings.
@@ -350,13 +370,21 @@ Collection.prototype.find = function() {
  * @param {boolean} [options.j=false] Specify a journal write concern.
  * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
  * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~insertOneWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.insertOne = function(doc, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
-  if(Array.isArray(doc)) return callback(new MongoError('doc parameter must be an object'));
+  options = options || {};
+  if(Array.isArray(doc)) return callback(MongoError.create({message: 'doc parameter must be an object', driver:true }));
+
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
 
   // Execute using callback
   if(typeof callback == 'function') return insertOne(self, doc, options, callback);
@@ -365,7 +393,7 @@ Collection.prototype.insertOne = function(doc, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     insertOne(self, doc, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -380,11 +408,35 @@ var insertOne = function(self, doc, options, callback) {
     r.insertedCount = r.result.n;
     r.insertedId = doc._id;
     if(callback) callback(null, r);
-  });  
+  });
 }
 
+var mapInserManyResults = function(docs, r) {
+  var ids = r.getInsertedIds();
+  var keys = Object.keys(ids);
+  var finalIds = new Array(keys);
+
+  for(var i = 0; i < keys.length; i++) {
+    if(ids[keys[i]]._id) {
+      finalIds[ids[keys[i]].index] = ids[keys[i]]._id;
+    }
+  }
+
+  return {
+    result: {ok: 1, n: r.insertedCount},
+    ops: docs,
+    insertedCount: r.insertedCount,
+    insertedIds: finalIds
+  }
+}
+
+define.classMethod('insertOne', {callback: true, promise:true});
+
 /**
- * Inserts an array of documents into MongoDB.
+ * Inserts an array of documents into MongoDB. If documents passed in do not contain the **_id** field, 
+ * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
+ * can be overridden by setting the **forceServerObjectId** flag.
+ *
  * @method
  * @param {object[]} docs Documents to insert.
  * @param {object} [options=null] Optional settings.
@@ -393,40 +445,56 @@ var insertOne = function(self, doc, options, callback) {
  * @param {boolean} [options.j=false] Specify a journal write concern.
  * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
  * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {Collection~insertWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.insertMany = function(docs, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
-  if(!Array.isArray(docs)) return callback(new MongoError('docs parameter must be an array of documents'));    
+  options = options || {ordered:true};
+  if(!Array.isArray(docs)) return callback(MongoError.create({message: 'docs parameter must be an array of documents', driver:true }));
+
+  // Get the write concern options
+  if(typeof options.checkKeys != 'boolean') {
+    options.checkKeys = true;
+  }
+
+  // If keep going set unordered
+  options['serializeFunctions'] = options['serializeFunctions'] || self.s.serializeFunctions;
+
+  // Set up the force server object id
+  var forceServerObjectId = typeof options.forceServerObjectId == 'boolean'
+    ? options.forceServerObjectId : self.s.db.options.forceServerObjectId;
+
+  // Do we want to force the server to assign the _id key
+  if(forceServerObjectId !== true) {
+    // Add _id if not specified
+    for(var i = 0; i < docs.length; i++) {
+      if(docs[i]._id == null) docs[i]._id = self.s.pkFactory.createPk();
+    }
+  }
+
+  // Generate the bulk write operations
+  var operations = [{
+    insertMany: docs
+  }];
 
   // Execute using callback
-  if(typeof callback == 'function') return insertMany(self, docs, options, callback);
+  if(typeof callback == 'function') return bulkWrite(self, operations, options, function(err, r) {
+    if(err) return callback(err, r);
+    callback(null, mapInserManyResults(docs, r));
+  });
 
   // Return a Promise
   return new this.s.promiseLibrary(function(resolve, reject) {
-    insertMany(self, docs, options, function(err, r) {
+    bulkWrite(self, operations, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(mapInserManyResults(docs, r));
     });
   });
 }
 
-var insertMany = function(self, docs, options, callback) {
-  insertDocuments(self, docs, options, function(err, r) {
-    if(callback == null) return;
-    if(err && callback) return callback(err);
-    if(r == null) return callback(null, {result: {ok:1}});
-    r.insertedCount = r.result.n;
-    var ids = [];
-    for(var i = 0; i < docs.length; i++) {
-      if(docs[i]._id) ids.push(docs[i]._id);
-    }
-    r.insertedIds = ids;
-    if(callback) callback(null, r);
-  });  
-}
+define.classMethod('insertMany', {callback: true, promise:true});
 
 /**
  * @typedef {Object} Collection~BulkWriteOpResult
@@ -464,6 +532,10 @@ var insertMany = function(self, docs, options, callback) {
  *
  *  { replaceOne: { filter: {c:3}, replacement: {c:4}, upsert:true}}
  *
+ * If documents passed in do not contain the **_id** field, 
+ * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
+ * can be overridden by setting the **forceServerObjectId** flag.
+ *
  * @method
  * @param {object[]} operations Bulk operations to perform.
  * @param {object} [options=null] Optional settings.
@@ -471,13 +543,19 @@ var insertMany = function(self, docs, options, callback) {
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
  * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
- * @param {Collection~bulkWriteOpCallback} callback The command result callback   
+ * @param {boolean} [options.ordered=true] Execute write operation in ordered or unordered fashion.
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~bulkWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.bulkWrite = function(operations, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
-  if(!Array.isArray(operations)) throw new MongoError("operations must be an array of documents");
+  options = options || {ordered:true};
+
+  if(!Array.isArray(operations)) {
+    throw MongoError.create({message: "operations must be an array of documents", driver:true });
+  }
 
   // Execute using callback
   if(typeof callback == 'function') return bulkWrite(self, operations, options, callback);
@@ -486,14 +564,21 @@ Collection.prototype.bulkWrite = function(operations, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     bulkWrite(self, operations, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var bulkWrite = function(self, operations, options, callback) {
-  var bulk = options.ordered == true || options.ordered == null ? self.initializeOrderedBulkOp() : self.initializeUnorderedBulkOp();
-  
+  // Add ignoreUndfined
+  if(self.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = self.s.options.ignoreUndefined;
+  }
+
+  // Create the bulk operation
+  var bulk = options.ordered == true || options.ordered == null ? self.initializeOrderedBulkOp(options) : self.initializeUnorderedBulkOp(options);
+
   // for each op go through and add to the bulk
   for(var i = 0; i < operations.length; i++) {
     bulk.raw(operations[i]);
@@ -505,6 +590,14 @@ var bulkWrite = function(self, operations, options, callback) {
 
   // Execute the bulk
   bulk.execute(writeCon, function(err, r) {
+    // We have connection level error
+    if(!r && err) return callback(err, null);
+    // We have single error
+    if(r && r.hasWriteErrors() && r.getWriteErrorCount() == 1) {
+      return callback(toError(r.getWriteErrorAt(0)), r);
+    }
+
+    // if(err) return callback(err);
     r.insertedCount = r.nInserted;
     r.matchedCount = r.nMatched;
     r.modifiedCount = r.nModified || 0;
@@ -513,6 +606,9 @@ var bulkWrite = function(self, operations, options, callback) {
     r.upsertedIds = {};
     r.insertedIds = {};
 
+    // Update the n
+    r.n = r.insertedCount;
+
     // Inserted documents
     var inserted = r.getInsertedIds();
     // Map inserted ids
@@ -525,7 +621,23 @@ var bulkWrite = function(self, operations, options, callback) {
     // Map upserted ids
     for(var i = 0; i < upserted.length; i++) {
       r.upsertedIds[upserted[i].index] = upserted[i]._id;
-    }    
+    }
+
+    // Check if we have write errors
+    if(r.hasWriteErrors()) {
+      // Get all the errors
+      var errors = r.getWriteErrors();
+      // Return the MongoError object
+      return callback(toError({
+        message: 'write operation failed', code: errors[0].code, writeErrors: errors
+      }), r);
+    }
+
+    // Check if we have a writeConcern error
+    if(r.getWriteConcernError()) {
+      // Return the MongoError object
+      return callback(toError(r.getWriteConcernError()), r);
+    }
 
     // Return the results
     callback(null, r);
@@ -546,9 +658,15 @@ var insertDocuments = function(self, docs, options, callback) {
   if(finalOptions.keepGoing == true) finalOptions.ordered = false;
   finalOptions['serializeFunctions'] = options['serializeFunctions'] || self.s.serializeFunctions;
 
+  // Set up the force server object id
+  var forceServerObjectId = typeof options.forceServerObjectId == 'boolean'
+    ? options.forceServerObjectId : self.s.db.options.forceServerObjectId;
+
   // Add _id if not specified
-  for(var i = 0; i < docs.length; i++) {
-    if(docs[i]._id == null) docs[i]._id = self.s.pkFactory.createPk();
+  if(forceServerObjectId !== true){
+    for(var i = 0; i < docs.length; i++) {
+      if(docs[i]._id == null) docs[i]._id = self.s.pkFactory.createPk();
+    }
   }
 
   // File inserts
@@ -561,10 +679,12 @@ var insertDocuments = function(self, docs, options, callback) {
     // Add docs to the list
     result.ops = docs;
     // Return the results
-    handleCallback(callback, null, result);   
-  });  
+    handleCallback(callback, null, result);
+  });
 }
 
+define.classMethod('bulkWrite', {callback: true, promise:true});
+
 /**
  * @typedef {Object} Collection~WriteOpResult
  * @property {object[]} ops All the documents inserted using insertOne/insertMany/replaceOne. Documents contain the _id field if forceServerObjectId == false for insertOne/insertMany
@@ -580,7 +700,46 @@ var insertDocuments = function(self, docs, options, callback) {
  */
 
 /**
- * Inserts a single document or a an array of documents into MongoDB.
+ * @typedef {Object} Collection~insertWriteOpResult
+ * @property {Number} insertedCount The total amount of documents inserted.
+ * @property {object[]} ops All the documents inserted using insertOne/insertMany/replaceOne. Documents contain the _id field if forceServerObjectId == false for insertOne/insertMany
+ * @property {ObjectId[]} insertedIds All the generated _id's for the inserted documents.
+ * @property {object} connection The connection object used for the operation.
+ * @property {object} result The raw command result object returned from MongoDB (content might vary by server version).
+ * @property {Number} result.ok Is 1 if the command executed correctly.
+ * @property {Number} result.n The total count of documents inserted.
+ */
+
+/**
+ * @typedef {Object} Collection~insertOneWriteOpResult
+ * @property {Number} insertedCount The total amount of documents inserted.
+ * @property {object[]} ops All the documents inserted using insertOne/insertMany/replaceOne. Documents contain the _id field if forceServerObjectId == false for insertOne/insertMany
+ * @property {ObjectId} insertedId The driver generated ObjectId for the insert operation.
+ * @property {object} connection The connection object used for the operation.
+ * @property {object} result The raw command result object returned from MongoDB (content might vary by server version).
+ * @property {Number} result.ok Is 1 if the command executed correctly.
+ * @property {Number} result.n The total count of documents inserted.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~insertWriteOpCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~insertWriteOpResult} result The result object if the command was executed successfully.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~insertOneWriteOpCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~insertOneWriteOpResult} result The result object if the command was executed successfully.
+ */
+
+/**
+ * Inserts a single document or a an array of documents into MongoDB. If documents passed in do not contain the **_id** field, 
+ * one will be added to each of the documents missing it by the driver, mutating the document. This behavior
+ * can be overridden by setting the **forceServerObjectId** flag.
+ *
  * @method
  * @param {(object|object[])} docs Documents to insert.
  * @param {object} [options=null] Optional settings.
@@ -589,27 +748,47 @@ var insertDocuments = function(self, docs, options, callback) {
  * @param {boolean} [options.j=false] Specify a journal write concern.
  * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
  * @param {boolean} [options.forceServerObjectId=false] Force server to assign _id values instead of driver.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~insertWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  * @deprecated Use insertOne, insertMany or bulkWrite
  */
 Collection.prototype.insert = function(docs, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
-  options = options || {};
+  options = options || {ordered:false};
+  docs = !Array.isArray(docs) ? [docs] : docs;
 
-  // Execute using callback
-  if(typeof callback == 'function') return insertDocuments(self, docs, options, callback);
+  if(options.keepGoing == true) {
+    options.ordered = false;
+  }
 
-  // Return a Promise
-  return new this.s.promiseLibrary(function(resolve, reject) {
-    insertDocuments(self, docs, options, function(err, r) {
-      if(err) return reject(err);
-      resolve(r); 
-    });
-  });
+  return this.insertMany(docs, options, callback);
 }
 
+define.classMethod('insert', {callback: true, promise:true});
+
+/**
+ * @typedef {Object} Collection~updateWriteOpResult
+ * @property {Object} result The raw result returned from MongoDB, field will vary depending on server version.
+ * @property {Number} result.ok Is 1 if the command executed correctly.
+ * @property {Number} result.n The total count of documents scanned.
+ * @property {Number} result.nModified The total count of documents modified.
+ * @property {Object} connection The connection object used for the operation.
+ * @property {Number} matchedCount The number of documents that matched the filter.
+ * @property {Number} modifiedCount The number of documents that were modified.
+ * @property {Number} upsertedCount The number of documents upserted.
+ * @property {Object} upsertedId The upserted id.
+ * @property {ObjectId} upsertedId._id The upserted _id returned from the server.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~updateWriteOpCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~updateWriteOpResult} result The result object if the command was executed successfully.
+ */
+
 /**
  * Update a single document on MongoDB
  * @method
@@ -620,7 +799,8 @@ Collection.prototype.insert = function(docs, options, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~updateWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.updateOne = function(filter, update, options, callback) {
@@ -628,6 +808,12 @@ Collection.prototype.updateOne = function(filter, update, options, callback) {
   if(typeof options == 'function') callback = options, options = {};
   options = shallowClone(options)
 
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
+
   // Execute using callback
   if(typeof callback == 'function') return updateOne(self, filter, update, options, callback);
 
@@ -635,7 +821,7 @@ Collection.prototype.updateOne = function(filter, update, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     updateOne(self, filter, update, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -653,9 +839,11 @@ var updateOne = function(self, filter, update, options, callback) {
     r.upsertedId = Array.isArray(r.result.upserted) && r.result.upserted.length > 0 ? r.result.upserted[0] : null;
     r.upsertedCount = Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
     if(callback) callback(null, r);
-  });  
+  });
 }
 
+define.classMethod('updateOne', {callback: true, promise:true});
+
 /**
  * Replace a document on MongoDB
  * @method
@@ -666,7 +854,8 @@ var updateOne = function(self, filter, update, options, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~updateWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.replaceOne = function(filter, update, options, callback) {
@@ -674,6 +863,12 @@ Collection.prototype.replaceOne = function(filter, update, options, callback) {
   if(typeof options == 'function') callback = options, options = {};
   options = shallowClone(options)
 
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
+
   // Execute using callback
   if(typeof callback == 'function') return replaceOne(self, filter, update, options, callback);
 
@@ -681,7 +876,7 @@ Collection.prototype.replaceOne = function(filter, update, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     replaceOne(self, filter, update, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -700,9 +895,11 @@ var replaceOne = function(self, filter, update, options, callback) {
     r.upsertedCount = Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
     r.ops = [update];
     if(callback) callback(null, r);
-  });  
+  });
 }
 
+define.classMethod('replaceOne', {callback: true, promise:true});
+
 /**
  * Update multiple documents on MongoDB
  * @method
@@ -713,7 +910,7 @@ var replaceOne = function(self, filter, update, options, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {Collection~updateWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.updateMany = function(filter, update, options, callback) {
@@ -721,6 +918,12 @@ Collection.prototype.updateMany = function(filter, update, options, callback) {
   if(typeof options == 'function') callback = options, options = {};
   options = shallowClone(options)
 
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
+
   // Execute using callback
   if(typeof callback == 'function') return updateMany(self, filter, update, options, callback);
 
@@ -728,7 +931,7 @@ Collection.prototype.updateMany = function(filter, update, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     updateMany(self, filter, update, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -746,9 +949,11 @@ var updateMany = function(self, filter, update, options, callback) {
     r.upsertedId = Array.isArray(r.result.upserted) && r.result.upserted.length > 0 ? r.result.upserted[0] : null;
     r.upsertedCount = Array.isArray(r.result.upserted) && r.result.upserted.length ? r.result.upserted.length : 0;
     if(callback) callback(null, r);
-  });  
+  });
 }
 
+define.classMethod('updateMany', {callback: true, promise:true});
+
 var updateDocuments = function(self, selector, document, options, callback) {
   if('function' === typeof options) callback = options, options = null;
   if(options == null) options = {};
@@ -768,8 +973,8 @@ var updateDocuments = function(self, selector, document, options, callback) {
 
   // Execute the operation
   var op = {q: selector, u: document};
-  if(options.upsert) op.upsert = true;
-  if(options.multi) op.multi = true;
+  op.upsert = typeof options.upsert == 'boolean' ? options.upsert : false;
+  op.multi = typeof options.multi == 'boolean' ? options.multi : false;
 
   // Update options
   self.s.topology.update(self.s.namespace, [op], finalOptions, function(err, result) {
@@ -779,8 +984,8 @@ var updateDocuments = function(self, selector, document, options, callback) {
     if(result.result.code) return handleCallback(callback, toError(result.result));
     if(result.result.writeErrors) return handleCallback(callback, toError(result.result.writeErrors[0]));
     // Return the results
-    handleCallback(callback, null, result);   
-  });  
+    handleCallback(callback, null, result);
+  });
 }
 
 /**
@@ -794,13 +999,21 @@ var updateDocuments = function(self, selector, document, options, callback) {
  * @param {boolean} [options.j=false] Specify a journal write concern.
  * @param {boolean} [options.upsert=false] Update operation is an upsert.
  * @param {boolean} [options.multi=false] Update one/all documents with operation.
- * @param {Collection~writeOpCallback} callback The command result callback
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~writeOpCallback} [callback] The command result callback
  * @throws {MongoError}
  * @return {Promise} returns Promise if no callback passed
  * @deprecated use updateOne, updateMany or bulkWrite
  */
 Collection.prototype.update = function(selector, document, options, callback) {
   var self = this;
+
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
+
   // Execute using callback
   if(typeof callback == 'function') return updateDocuments(self, selector, document, options, callback);
 
@@ -808,11 +1021,29 @@ Collection.prototype.update = function(selector, document, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     updateDocuments(self, selector, document, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
+define.classMethod('update', {callback: true, promise:true});
+
+/**
+ * @typedef {Object} Collection~deleteWriteOpResult
+ * @property {Object} result The raw result returned from MongoDB, field will vary depending on server version.
+ * @property {Number} result.ok Is 1 if the command executed correctly.
+ * @property {Number} result.n The total count of documents deleted.
+ * @property {Object} connection The connection object used for the operation.
+ * @property {Number} deletedCount The number of documents deleted.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~deleteWriteOpCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~deleteWriteOpResult} result The result object if the command was executed successfully.
+ */
+
 /**
  * Delete a document on MongoDB
  * @method
@@ -821,13 +1052,20 @@ Collection.prototype.update = function(selector, document, options, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~deleteWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.deleteOne = function(filter, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
-  var options = shallowClone(options);    
+  var options = shallowClone(options);
+
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
 
   // Execute using callback
   if(typeof callback == 'function') return deleteOne(self, filter, options, callback);
@@ -836,7 +1074,7 @@ Collection.prototype.deleteOne = function(filter, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     deleteOne(self, filter, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -849,11 +1087,15 @@ var deleteOne = function(self, filter, options, callback) {
     if(r == null) return callback(null, {result: {ok:1}});
     r.deletedCount = r.result.n;
     if(callback) callback(null, r);
-  });  
+  });
 }
 
+define.classMethod('deleteOne', {callback: true, promise:true});
+
 Collection.prototype.removeOne = Collection.prototype.deleteOne;
 
+define.classMethod('removeOne', {callback: true, promise:true});
+
 /**
  * Delete multiple documents on MongoDB
  * @method
@@ -862,13 +1104,19 @@ Collection.prototype.removeOne = Collection.prototype.deleteOne;
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~writeOpCallback} callback The command result callback   
+ * @param {Collection~deleteWriteOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.deleteMany = function(filter, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
-  var options = shallowClone(options);    
+  var options = shallowClone(options);
+
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
 
   // Execute using callback
   if(typeof callback == 'function') return deleteMany(self, filter, options, callback);
@@ -877,7 +1125,7 @@ Collection.prototype.deleteMany = function(filter, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     deleteMany(self, filter, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -890,11 +1138,9 @@ var deleteMany = function(self, filter, options, callback) {
     if(r == null) return callback(null, {result: {ok:1}});
     r.deletedCount = r.result.n;
     if(callback) callback(null, r);
-  });  
+  });
 }
 
-Collection.prototype.removeMany = Collection.prototype.deleteMany;
-
 var removeDocuments = function(self, selector, options, callback) {
   if(typeof options == 'function') {
     callback = options, options = {};
@@ -925,10 +1171,16 @@ var removeDocuments = function(self, selector, options, callback) {
     if(result.result.code) return handleCallback(callback, toError(result.result));
     if(result.result.writeErrors) return handleCallback(callback, toError(result.result.writeErrors[0]));
     // Return the results
-    handleCallback(callback, null, result);   
-  });  
+    handleCallback(callback, null, result);
+  });
 }
 
+define.classMethod('deleteMany', {callback: true, promise:true});
+
+Collection.prototype.removeMany = Collection.prototype.deleteMany;
+
+define.classMethod('removeMany', {callback: true, promise:true});
+
 /**
  * Remove documents.
  * @method
@@ -938,12 +1190,19 @@ var removeDocuments = function(self, selector, options, callback) {
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
  * @param {boolean} [options.single=false] Removes the first document found.
- * @param {Collection~writeOpCallback} callback The command result callback
+ * @param {Collection~writeOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  * @deprecated use deleteOne, deleteMany or bulkWrite
  */
 Collection.prototype.remove = function(selector, options, callback) {
   var self = this;
+
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
+
   // Execute using callback
   if(typeof callback == 'function') return removeDocuments(self, selector, options, callback);
 
@@ -951,11 +1210,13 @@ Collection.prototype.remove = function(selector, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     removeDocuments(self, selector, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
+define.classMethod('remove', {callback: true, promise:true});
+
 /**
  * Save a document. Simple full document replacement function. Not recommended for efficiency, use atomic
  * operators and update instead for more efficient operations.
@@ -965,14 +1226,21 @@ Collection.prototype.remove = function(selector, options, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~writeOpCallback} callback The command result callback
+ * @param {Collection~writeOpCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
+ * @deprecated use insertOne, insertMany, updateOne or updateMany
  */
 Collection.prototype.save = function(doc, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
   options = options || {};
 
+  // Add ignoreUndfined
+  if(this.s.options.ignoreUndefined) {
+    options = shallowClone(options);
+    options.ignoreUndefined = this.s.options.ignoreUndefined;
+  }
+
   // Execute using callback
   if(typeof callback == 'function') return save(self, doc, options, callback);
 
@@ -980,7 +1248,7 @@ Collection.prototype.save = function(doc, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     save(self, doc, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1000,9 +1268,11 @@ var save = function(self, doc, options, callback) {
     if(doc == null) return handleCallback(callback, null, null);
     if(err) return handleCallback(callback, err, null);
     handleCallback(callback, null, r);
-  });  
+  });
 }
 
+define.classMethod('save', {callback: true, promise:true});
+
 /**
  * The callback format for results
  * @callback Collection~resultCallback
@@ -1017,7 +1287,7 @@ var save = function(self, doc, options, callback) {
  * @param {object} [options=null] Optional settings.
  * @param {number} [options.limit=0] Sets the limit of documents returned in the query.
  * @param {(array|object)} [options.sort=null] Set to sort the documents coming back from the query. Array of indexes, [['a', 1]] etc.
- * @param {object} [options.fields=null] The fields to return in the query. Object of fields to include or exclude (not both), {'a':1} 
+ * @param {object} [options.fields=null] The fields to return in the query. Object of fields to include or exclude (not both), {'a':1}
  * @param {number} [options.skip=0] Set to skip N documents ahead in your query (useful for pagination).
  * @param {Object} [options.hint=null] Tell the query to use specific indexes in the query. Object of indexes to use, {'_id':1}
  * @param {boolean} [options.explain=false] Explain the query instead of returning the data.
@@ -1026,7 +1296,7 @@ var save = function(self, doc, options, callback) {
  * @param {boolean} [options.tailable=false] Specify if the cursor is tailable.
  * @param {number} [options.batchSize=0] Set the batchSize for the getMoreCommand when iterating over the query results.
  * @param {boolean} [options.returnKey=false] Only return the index key.
- * @param {number} [options.maxScan=null] Limit the number of items to scan. 
+ * @param {number} [options.maxScan=null] Limit the number of items to scan.
  * @param {number} [options.min=null] Set index bounds.
  * @param {number} [options.max=null] Set index bounds.
  * @param {boolean} [options.showDiskLoc=false] Show disk location of results.
@@ -1035,10 +1305,11 @@ var save = function(self, doc, options, callback) {
  * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  * @param {boolean} [options.partial=false] Specify if the cursor should return partial results when querying against a sharded system
  * @param {number} [options.maxTimeMS=null] Number of miliseconds to wait before aborting the query.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
+ * @deprecated use find().limit(1).next(function(err, doc){})
  */
-Collection.prototype.findOne = function() {    
+Collection.prototype.findOne = function() {
   var self = this;
   var args = Array.prototype.slice.call(arguments, 0);
   var callback = args.pop();
@@ -1051,7 +1322,7 @@ Collection.prototype.findOne = function() {
   return new this.s.promiseLibrary(function(resolve, reject) {
     findOne(self, args, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1065,6 +1336,8 @@ var findOne = function(self, args, callback) {
   });
 }
 
+define.classMethod('findOne', {callback: true, promise:true});
+
 /**
  * The callback format for the collection method, must be used if strict is specified
  * @callback Collection~collectionResultCallback
@@ -1079,7 +1352,7 @@ var findOne = function(self, args, callback) {
  * @param {string} newName New name of of the collection.
  * @param {object} [options=null] Optional settings.
  * @param {boolean} [options.dropTarget=false] Drop the target name collection if it previously exists.
- * @param {Collection~collectionResultCallback} callback The results callback
+ * @param {Collection~collectionResultCallback} [callback] The results callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.rename = function(newName, opt, callback) {
@@ -1094,7 +1367,7 @@ Collection.prototype.rename = function(newName, opt, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     rename(self, newName, opt, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1118,14 +1391,16 @@ var rename = function(self, newName, opt, callback) {
     } catch(err) {
       return handleCallback(callback, toError(err), null);
     }
-  });  
+  });
 }
 
+define.classMethod('rename', {callback: true, promise:true});
+
 /**
  * Drop the collection from the database, removing it permanently. New accesses will create a new collection.
  *
  * @method
- * @param {Collection~resultCallback} callback The results callback
+ * @param {Collection~resultCallback} [callback] The results callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.drop = function(callback) {
@@ -1137,16 +1412,18 @@ Collection.prototype.drop = function(callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     self.s.db.dropCollection(self.s.name, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
+define.classMethod('drop', {callback: true, promise:true});
+
 /**
  * Returns the options of the collection.
  *
  * @method
- * @param {Collection~resultCallback} callback The results callback
+ * @param {Collection~resultCallback} [callback] The results callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.options = function(callback) {
@@ -1159,7 +1436,7 @@ Collection.prototype.options = function(callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     options(self, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1167,16 +1444,21 @@ Collection.prototype.options = function(callback) {
 var options = function(self, callback) {
   self.s.db.listCollections({name: self.s.name}).toArray(function(err, collections) {
     if(err) return handleCallback(callback, err);
-    if(collections.length == 0) return handleCallback(callback, new MongoError(f("collection %s not found", self.s.namespace)));
-    handleCallback(callback, err, collections[0].options || null);      
-  });  
+    if(collections.length == 0) {
+      return handleCallback(callback, MongoError.create({message: f("collection %s not found", self.s.namespace), driver:true }));
+    }
+
+    handleCallback(callback, err, collections[0].options || null);
+  });
 }
 
+define.classMethod('options', {callback: true, promise:true});
+
 /**
  * Returns if the collection is a capped collection
  *
  * @method
- * @param {Collection~resultCallback} callback The results callback
+ * @param {Collection~resultCallback} [callback] The results callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.isCapped = function(callback) {
@@ -1189,7 +1471,7 @@ Collection.prototype.isCapped = function(callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     isCapped(self, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1198,9 +1480,11 @@ var isCapped = function(self, callback) {
   self.options(function(err, document) {
     if(err) return handleCallback(callback, err);
     handleCallback(callback, null, document && document.capped);
-  });    
+  });
 }
 
+define.classMethod('isCapped', {callback: true, promise:true});
+
 /**
  * Creates an index on the db and collection collection.
  * @method
@@ -1218,7 +1502,7 @@ var isCapped = function(self, callback) {
  * @param {number} [options.v=null] Specify the format version of the indexes.
  * @param {number} [options.expireAfterSeconds=null] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
  * @param {number} [options.name=null] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.createIndex = function(fieldOrSpec, options, callback) {
@@ -1237,22 +1521,24 @@ Collection.prototype.createIndex = function(fieldOrSpec, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     createIndex(self, fieldOrSpec, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var createIndex = function(self, fieldOrSpec, options, callback) {
-  self.s.db.createIndex(self.s.name, fieldOrSpec, options, callback);  
+  self.s.db.createIndex(self.s.name, fieldOrSpec, options, callback);
 }
 
+define.classMethod('createIndex', {callback: true, promise:true});
+
 /**
  * Creates multiple indexes in the collection, this method is only supported for
  * MongoDB 2.6 or higher. Earlier version of MongoDB will throw a command not supported
  * error. Index specifications are defined at http://docs.mongodb.org/manual/reference/command/createIndexes/.
  * @method
- * @param {array} indexSpecs An array of index specifications to be created 
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {array} indexSpecs An array of index specifications to be created
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.createIndexes = function(indexSpecs, callback) {
@@ -1265,7 +1551,7 @@ Collection.prototype.createIndexes = function(indexSpecs, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     createIndexes(self, indexSpecs, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1286,11 +1572,13 @@ var createIndexes = function(self, indexSpecs, callback) {
   }
 
   // Execute the index
-  self.s.db.command({ 
+  self.s.db.command({
     createIndexes: self.s.name, indexes: indexSpecs
-  }, callback);  
+  }, callback);
 }
 
+define.classMethod('createIndexes', {callback: true, promise:true});
+
 /**
  * Drops an index from this collection.
  * @method
@@ -1299,7 +1587,7 @@ var createIndexes = function(self, indexSpecs, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.dropIndex = function(indexName, options, callback) {
@@ -1318,27 +1606,29 @@ Collection.prototype.dropIndex = function(indexName, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     dropIndex(self, indexName, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var dropIndex = function(self, indexName, options, callback) {
   // Delete index command
-  var cmd = {'deleteIndexes':self.s.name, 'index':indexName};  
+  var cmd = {'deleteIndexes':self.s.name, 'index':indexName};
 
   // Execute command
   self.s.db.command(cmd, options, function(err, result) {
     if(typeof callback != 'function') return;
     if(err) return handleCallback(callback, err, null);
     handleCallback(callback, null, result);
-  });  
+  });
 }
 
+define.classMethod('dropIndex', {callback: true, promise:true});
+
 /**
  * Drops all indexes from this collection.
  * @method
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.dropIndexes = function(callback) {
@@ -1351,7 +1641,7 @@ Collection.prototype.dropIndexes = function(callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     dropIndexes(self, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1363,27 +1653,31 @@ var dropIndexes = function(self, callback) {
   });
 }
 
+define.classMethod('dropIndexes', {callback: true, promise:true});
+
 /**
  * Drops all indexes from this collection.
  * @method
  * @deprecated use dropIndexes
  * @param {Collection~resultCallback} callback The command result callback
- * @return {Promise} returns Promise if no callback passed
+ * @return {Promise} returns Promise if no [callback] passed
  */
 Collection.prototype.dropAllIndexes = Collection.prototype.dropIndexes;
 
+define.classMethod('dropAllIndexes', {callback: true, promise:true});
+
 /**
  * Reindex all indexes on the collection
  * Warning: reIndex is a blocking operation (indexes are rebuilt in the foreground) and will be slow for large collections.
  * @method
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.reIndex = function(options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
   options = options || {};
-  
+
   // Execute using callback
   if(typeof callback == 'function') return reIndex(self, options, callback);
 
@@ -1391,7 +1685,7 @@ Collection.prototype.reIndex = function(options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     reIndex(self, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1405,15 +1699,18 @@ var reIndex = function(self, options, callback) {
     if(callback == null) return;
     if(err) return handleCallback(callback, err, null);
     handleCallback(callback, null, result.ok ? true : false);
-  });  
+  });
 }
 
+define.classMethod('reIndex', {callback: true, promise:true});
+
 /**
  * Get the list of all indexes information for the collection.
  *
  * @method
  * @param {object} [options=null] Optional settings.
  * @param {number} [options.batchSize=null] The batchSize for the returned command cursor or if pre 2.8 the systems batch collection
+ * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  * @return {CommandCursor}
  */
 Collection.prototype.listIndexes = function(options) {
@@ -1425,22 +1722,38 @@ Collection.prototype.listIndexes = function(options) {
   // Set the promiseLibrary
   options.promiseLibrary = this.s.promiseLibrary;
 
+  if(!this.s.topology.capabilities()) {
+    throw new MongoError('cannot connect to server');
+  }
+
   // We have a list collections command
-  if(this.s.db.serverConfig.capabilities().hasListIndexesCommand) {
+  if(this.s.topology.capabilities().hasListIndexesCommand) {
     // Cursor options
     var cursor = options.batchSize ? {batchSize: options.batchSize} : {}
     // Build the command
     var command = { listIndexes: this.s.name, cursor: cursor };
     // Execute the cursor
-    return this.s.topology.cursor(f('%s.$cmd', this.s.dbName), command, options);
+    var cursor = this.s.topology.cursor(f('%s.$cmd', this.s.dbName), command, options);
+    // Do we have a readPreference, apply it
+    if(options.readPeference) cursor.setReadPreference(options.readPeference);
+    // Return the cursor
+    return cursor;
   }
 
   // Get the namespace
   var ns = f('%s.system.indexes', this.s.dbName);
   // Get the query
-  return this.s.topology.cursor(ns, {find: ns, query: {ns: this.s.namespace}}, options);
+  var cursor = this.s.topology.cursor(ns, {find: ns, query: {ns: this.s.namespace}}, options);
+  // Do we have a readPreference, apply it
+  if(options.readPeference) cursor.setReadPreference(options.readPeference);
+  // Set the passed in batch size if one was provided
+  if(options.batchSize) cursor = cursor.batchSize(options.batchSize);
+  // Return the cursor
+  return cursor;
 };
 
+define.classMethod('listIndexes', {callback: false, promise:false, returns: [CommandCursor]});
+
 /**
  * Ensures that an index exists, if it does not it creates it
  * @method
@@ -1459,7 +1772,7 @@ Collection.prototype.listIndexes = function(options) {
  * @param {number} [options.v=null] Specify the format version of the indexes.
  * @param {number} [options.expireAfterSeconds=null] Allows you to expire data on indexes applied to a data (MongoDB 2.2 or higher)
  * @param {number} [options.name=null] Override the autogenerated index name (useful if the resulting name is larger than 128 bytes)
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.ensureIndex = function(fieldOrSpec, options, callback) {
@@ -1474,20 +1787,22 @@ Collection.prototype.ensureIndex = function(fieldOrSpec, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     ensureIndex(self, fieldOrSpec, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var ensureIndex = function(self, fieldOrSpec, options, callback) {
-  self.s.db.ensureIndex(self.s.name, fieldOrSpec, options, callback);  
+  self.s.db.ensureIndex(self.s.name, fieldOrSpec, options, callback);
 }
 
+define.classMethod('ensureIndex', {callback: true, promise:true});
+
 /**
  * Checks if one or more indexes exist on the collection, fails on first non-existing index
  * @method
  * @param {(string|array)} indexes One or more index names to check.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.indexExists = function(indexes, callback) {
@@ -1500,7 +1815,7 @@ Collection.prototype.indexExists = function(indexes, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     indexExists(self, indexes, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1520,15 +1835,17 @@ var indexExists = function(self, indexes, callback) {
 
     // All keys found return true
     return handleCallback(callback, null, true);
-  });      
+  });
 }
 
+define.classMethod('indexExists', {callback: true, promise:true});
+
 /**
  * Retrieves this collections index info.
  * @method
  * @param {object} [options=null] Optional settings.
  * @param {boolean} [options.full=false] Returns the full raw index information.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.indexInformation = function(options, callback) {
@@ -1546,15 +1863,17 @@ Collection.prototype.indexInformation = function(options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     indexInformation(self, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var indexInformation = function(self, options, callback) {
-  self.s.db.indexInformation(self.s.name, options, callback);      
+  self.s.db.indexInformation(self.s.name, options, callback);
 }
 
+define.classMethod('indexInformation', {callback: true, promise:true});
+
 /**
  * The callback format for results
  * @callback Collection~countCallback
@@ -1571,7 +1890,7 @@ var indexInformation = function(self, options, callback) {
  * @param {boolean} [options.skip=null] The number of documents to skip for the count.
  * @param {string} [options.hint=null] An index name hint for the query.
  * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
- * @param {Collection~countCallback} callback The command result callback
+ * @param {Collection~countCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.count = function(query, options, callback) {
@@ -1593,7 +1912,7 @@ Collection.prototype.count = function(query, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     count(self, query, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 };
@@ -1606,8 +1925,7 @@ var count = function(self, query, options, callback) {
 
   // Final query
   var cmd = {
-      'count': self.s.name, 'query': query
-    , 'fields': null
+    'count': self.s.name, 'query': query
   };
 
   // Add limit and skip if defined
@@ -1618,13 +1936,20 @@ var count = function(self, query, options, callback) {
   // Ensure we have the right read preference inheritance
   options = getReadPreference(self, options, self.s.db, self);
 
+  // Do we have a readConcern specified
+  if(self.s.readConcern) {
+    cmd.readConcern = self.s.readConcern;
+  }
+
   // Execute command
   self.s.db.command(cmd, options, function(err, result) {
     if(err) return handleCallback(callback, err);
     handleCallback(callback, null, result.n);
-  });  
+  });
 }
 
+define.classMethod('count', {callback: true, promise:true});
+
 /**
  * The distinct command returns returns a list of distinct values for the given key across a collection.
  * @method
@@ -1632,7 +1957,7 @@ var count = function(self, query, options, callback) {
  * @param {object} query The query for filtering the set of documents to which we apply the distinct filter.
  * @param {object} [options=null] Optional settings.
  * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.distinct = function(key, query, options, callback) {
@@ -1654,7 +1979,7 @@ Collection.prototype.distinct = function(key, query, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     distinct(self, key, query, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 };
@@ -1671,17 +1996,24 @@ var distinct = function(self, key, query, options, callback) {
   // Ensure we have the right read preference inheritance
   options = getReadPreference(self, options, self.s.db, self);
 
+  // Do we have a readConcern specified
+  if(self.s.readConcern) {
+    cmd.readConcern = self.s.readConcern;
+  }
+
   // Execute the command
   self.s.db.command(cmd, options, function(err, result) {
     if(err) return handleCallback(callback, err);
     handleCallback(callback, null, result.values);
-  });  
+  });
 }
 
+define.classMethod('distinct', {callback: true, promise:true});
+
 /**
  * Retrieve all the indexes on the collection.
  * @method
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.indexes = function(callback) {
@@ -1693,22 +2025,24 @@ Collection.prototype.indexes = function(callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     indexes(self, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var indexes = function(self, callback) {
-  self.s.db.indexInformation(self.s.name, {full:true}, callback);    
+  self.s.db.indexInformation(self.s.name, {full:true}, callback);
 }
 
+define.classMethod('indexes', {callback: true, promise:true});
+
 /**
  * Get all the collection statistics.
  *
  * @method
  * @param {object} [options=null] Optional settings.
  * @param {number} [options.scale=null] Divide the returned sizes by scale value.
- * @param {Collection~resultCallback} callback The collection result callback
+ * @param {Collection~resultCallback} [callback] The collection result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.stats = function(options, callback) {
@@ -1726,7 +2060,7 @@ Collection.prototype.stats = function(options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     stats(self, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1744,9 +2078,25 @@ var stats = function(self, options, callback) {
   options = getReadPreference(self, options, self.s.db, self);
 
   // Execute the command
-  self.s.db.command(commandObject, options, callback);  
+  self.s.db.command(commandObject, options, callback);
 }
 
+define.classMethod('stats', {callback: true, promise:true});
+
+/**
+ * @typedef {Object} Collection~findAndModifyWriteOpResult
+ * @property {object} value Document returned from findAndModify command.
+ * @property {object} lastErrorObject The raw lastErrorObject returned from the command.
+ * @property {Number} ok Is 1 if the command executed correctly.
+ */
+
+/**
+ * The callback format for inserts
+ * @callback Collection~findAndModifyCallback
+ * @param {MongoError} error An error instance representing the error during the execution.
+ * @param {Collection~findAndModifyWriteOpResult} result The result object if the command was executed successfully.
+ */
+
 /**
  * Find a document and delete it in one atomic operation, requires a write lock for the duration of the operation.
  *
@@ -1756,38 +2106,45 @@ var stats = function(self, options, callback) {
  * @param {object} [options.projection=null] Limits the fields to return for all matching documents.
  * @param {object} [options.sort=null] Determines which document the operation modifies if the query selects multiple documents.
  * @param {number} [options.maxTimeMS=null] The maximum amount of time to allow the query to run.
- * @param {Collection~resultCallback} callback The collection result callback
+ * @param {Collection~findAndModifyCallback} [callback] The collection result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.findOneAndDelete = function(filter, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
+  options = options || {};
 
   // Execute using callback
   if(typeof callback == 'function') return findOneAndDelete(self, filter, options, callback);
 
   // Return a Promise
   return new this.s.promiseLibrary(function(resolve, reject) {
+    options = options || {};
+
     findOneAndDelete(self, filter, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var findOneAndDelete = function(self, filter, options, callback) {
+  // Final options
+  var finalOptions = shallowClone(options);
+  finalOptions['fields'] = options.projection;
+  finalOptions['remove'] = true;
+  // Execute find and Modify
   self.findAndModify(
       filter
     , options.sort
     , null
-    , {
-        fields: options.projection
-      , remove:true
-    }
+    , finalOptions
     , callback
-  );  
+  );
 }
 
+define.classMethod('findOneAndDelete', {callback: true, promise:true});
+
 /**
  * Find a document and replace it in one atomic operation, requires a write lock for the duration of the operation.
  *
@@ -1800,40 +2157,48 @@ var findOneAndDelete = function(self, filter, options, callback) {
  * @param {number} [options.maxTimeMS=null] The maximum amount of time to allow the query to run.
  * @param {boolean} [options.upsert=false] Upsert the document if it does not exist.
  * @param {boolean} [options.returnOriginal=true] When false, returns the updated document rather than the original. The default is true.
- * @param {Collection~resultCallback} callback The collection result callback
+ * @param {Collection~findAndModifyCallback} [callback] The collection result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.findOneAndReplace = function(filter, replacement, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
+  options = options || {};
 
   // Execute using callback
   if(typeof callback == 'function') return findOneAndReplace(self, filter, replacement, options, callback);
 
   // Return a Promise
   return new this.s.promiseLibrary(function(resolve, reject) {
+    options = options || {};
+
     findOneAndReplace(self, filter, replacement, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var findOneAndReplace = function(self, filter, replacement, options, callback) {
+  // Final options
+  var finalOptions = shallowClone(options);
+  finalOptions['fields'] = options.projection;
+  finalOptions['update'] = true;
+  finalOptions['new'] = typeof options.returnOriginal == 'boolean' ? !options.returnOriginal : false;
+  finalOptions['upsert'] = typeof options.upsert == 'boolean' ? options.upsert : false;
+
+  // Execute findAndModify
   self.findAndModify(
       filter
     , options.sort
     , replacement
-    , {
-        fields: options.projection
-      , update: true
-      , new: typeof options.returnOriginal == 'boolean' ? !options.returnOriginal : false
-      , upsert: typeof options.upsert == 'boolean' ? options.upsert : false
-    }
+    , finalOptions
     , callback
-  );  
+  );
 }
 
+define.classMethod('findOneAndReplace', {callback: true, promise:true});
+
 /**
  * Find a document and update it in one atomic operation, requires a write lock for the duration of the operation.
  *
@@ -1846,40 +2211,48 @@ var findOneAndReplace = function(self, filter, replacement, options, callback) {
  * @param {number} [options.maxTimeMS=null] The maximum amount of time to allow the query to run.
  * @param {boolean} [options.upsert=false] Upsert the document if it does not exist.
  * @param {boolean} [options.returnOriginal=true] When false, returns the updated document rather than the original. The default is true.
- * @param {Collection~resultCallback} callback The collection result callback
+ * @param {Collection~findAndModifyCallback} [callback] The collection result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.findOneAndUpdate = function(filter, update, options, callback) {
   var self = this;
   if(typeof options == 'function') callback = options, options = {};
+  options = options || {};
 
   // Execute using callback
   if(typeof callback == 'function') return findOneAndUpdate(self, filter, update, options, callback);
 
   // Return a Promise
   return new this.s.promiseLibrary(function(resolve, reject) {
+    options = options || {};
+
     findOneAndUpdate(self, filter, update, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
 
 var findOneAndUpdate = function(self, filter, update, options, callback) {
+  // Final options
+  var finalOptions = shallowClone(options);
+  finalOptions['fields'] = options.projection;
+  finalOptions['update'] = true;
+  finalOptions['new'] = typeof options.returnOriginal == 'boolean' ? !options.returnOriginal : false;
+  finalOptions['upsert'] = typeof options.upsert == 'boolean' ? options.upsert : false;
+
+  // Execute findAndModify
   self.findAndModify(
       filter
     , options.sort
     , update
-    , {
-        fields: options.projection
-      , update: true
-      , new: typeof options.returnOriginal == 'boolean' ? !options.returnOriginal : false
-      , upsert: typeof options.upsert == 'boolean' ? options.upsert : false
-    }
+    , finalOptions
     , callback
-  );  
+  );
 }
 
+define.classMethod('findOneAndUpdate', {callback: true, promise:true});
+
 /**
  * Find and update a document.
  * @method
@@ -1894,9 +2267,9 @@ var findOneAndUpdate = function(self, filter, update, options, callback) {
  * @param {boolean} [options.upsert=false] Perform an upsert operation.
  * @param {boolean} [options.new=false] Set to true if you want to return the modified object rather than the original. Ignored for remove.
  * @param {object} [options.fields=null] Object containing the field projection for the result returned from the operation.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
- * @deprecated use findOneAndUpdate, findOneAndReplace or findOneAndDelete instead 
+ * @deprecated use findOneAndUpdate, findOneAndReplace or findOneAndDelete instead
  */
 Collection.prototype.findAndModify = function(query, sort, doc, options, callback) {
   var self = this;
@@ -1917,9 +2290,11 @@ Collection.prototype.findAndModify = function(query, sort, doc, options, callbac
 
   // Return a Promise
   return new this.s.promiseLibrary(function(resolve, reject) {
+    options = options || {};
+
     findAndModify(self, query, sort, doc, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -1959,14 +2334,29 @@ var findAndModify = function(self, query, sort, doc, options, callback) {
   // No check on the documents
   options.checkKeys = false;
 
+  // Get the write concern settings
+  var finalOptions = writeConcern(options, self.s.db, self, options);
+
+  // Decorate the findAndModify command with the write Concern
+  if(finalOptions.writeConcern) {
+    queryObject.writeConcern = finalOptions.writeConcern;
+  }
+
+  // Have we specified bypassDocumentValidation
+  if(typeof finalOptions.bypassDocumentValidation == 'boolean') {
+    queryObject.bypassDocumentValidation = finalOptions.bypassDocumentValidation;
+  }
+
   // Execute the command
   self.s.db.command(queryObject
     , options, function(err, result) {
       if(err) return handleCallback(callback, err, null);
       return handleCallback(callback, null, result);
-  });  
+  });
 }
 
+define.classMethod('findAndModify', {callback: true, promise:true});
+
 /**
  * Find and remove a document.
  * @method
@@ -1976,7 +2366,7 @@ var findAndModify = function(self, query, sort, doc, options, callback) {
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
  * @param {boolean} [options.j=false] Specify a journal write concern.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  * @deprecated use findOneAndDelete instead
  */
@@ -1995,7 +2385,7 @@ Collection.prototype.findAndRemove = function(query, sort, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     findAndRemove(self, query, sort, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -2007,6 +2397,8 @@ var findAndRemove = function(self, query, sort, options, callback) {
   self.findAndModify(query, sort, null, options, callback);
 }
 
+define.classMethod('findAndRemove', {callback: true, promise:true});
+
 /**
  * Execute an aggregation framework pipeline against the collection, needs MongoDB >= 2.2
  * @method
@@ -2018,6 +2410,7 @@ var findAndRemove = function(self, query, sort, options, callback) {
  * @param {boolean} [options.explain=false] Explain returns the aggregation execution plan (requires mongodb 2.6 >).
  * @param {boolean} [options.allowDiskUse=false] allowDiskUse lets the server know if it can use disk to store temporary results for the aggregation (requires mongodb 2.6 >).
  * @param {number} [options.maxTimeMS=null] maxTimeMS specifies a cumulative time limit in milliseconds for processing operations on the cursor. MongoDB interrupts the operation at the earliest following interrupt point.
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
  * @param {Collection~resultCallback} callback The command result callback
  * @return {(null|AggregationCursor)}
  */
@@ -2034,7 +2427,7 @@ Collection.prototype.aggregate = function(pipeline, options, callback) {
     // a cursor based aggregation
     if(options == null && callback == null) {
       options = {};
-    }      
+    }
   } else {
     // Aggregation pipeline passed as arguments on the method
     var args = Array.prototype.slice.call(arguments, 0);
@@ -2043,20 +2436,37 @@ Collection.prototype.aggregate = function(pipeline, options, callback) {
     // Get the possible options object
     var opts = args[args.length - 1];
     // If it contains any of the admissible options pop it of the args
-    options = opts && (opts.readPreference 
+    options = opts && (opts.readPreference
       || opts.explain || opts.cursor || opts.out
       || opts.maxTimeMS || opts.allowDiskUse) ? args.pop() : {};
       // Left over arguments is the pipeline
     pipeline = args;
   }
 
+  // Ignore readConcern option
+  var ignoreReadConcern = false;
+
   // If out was specified
   if(typeof options.out == 'string') {
     pipeline.push({$out: options.out});
+    ignoreReadConcern = true;
+  } else if(pipeline.length > 0 && pipeline[pipeline.length - 1]['$out']) {
+    ignoreReadConcern = true;
   }
 
   // Build the command
   var command = { aggregate : this.s.name, pipeline : pipeline};
+
+  // If we have bypassDocumentValidation set
+  if(typeof options.bypassDocumentValidation == 'boolean') {
+    command.bypassDocumentValidation = options.bypassDocumentValidation;
+  }
+
+  // Do we have a readConcern specified
+  if(!ignoreReadConcern && this.s.readConcern) {
+    command.readConcern = this.s.readConcern;
+  }
+
   // If we have allowDiskUse defined
   if(options.allowDiskUse) command.allowDiskUse = options.allowDiskUse;
   if(typeof options.maxTimeMS == 'number') command.maxTimeMS = options.maxTimeMS;
@@ -2078,9 +2488,13 @@ Collection.prototype.aggregate = function(pipeline, options, callback) {
   // Set the AggregationCursor constructor
   options.cursorFactory = AggregationCursor;
   if(typeof callback != 'function') {
+    if(!this.s.topology.capabilities()) {
+      throw new MongoError('cannot connect to server');
+    }
+
     if(this.s.topology.capabilities().hasAggregationCursor) {
       options.cursor = options.cursor || { batchSize : 1000 };
-      command.cursor = options.cursor;        
+      command.cursor = options.cursor;
     }
 
     // Allow disk usage command
@@ -2113,6 +2527,8 @@ Collection.prototype.aggregate = function(pipeline, options, callback) {
   });
 }
 
+define.classMethod('aggregate', {callback: true, promise:false});
+
 /**
  * The callback format for results
  * @callback Collection~parallelCollectionScanCallback
@@ -2129,7 +2545,7 @@ Collection.prototype.aggregate = function(pipeline, options, callback) {
  * @param {number} [options.batchSize=null] Set the batchSize for the getMoreCommand when iterating over the query results.
  * @param {number} [options.numCursors=1] The maximum number of parallel command cursors to return (the number of returned cursors will be in the range 1:numCursors)
  * @param {boolean} [options.raw=false] Return all BSON documents as Raw Buffer documents.
- * @param {Collection~parallelCollectionScanCallback} callback The command result callback
+ * @param {Collection~parallelCollectionScanCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.parallelCollectionScan = function(options, callback) {
@@ -2141,7 +2557,7 @@ Collection.prototype.parallelCollectionScan = function(options, callback) {
 
   // Ensure we have the right read preference inheritance
   options = getReadPreference(this, options, this.s.db, this);
-  
+
   // Add a promiseLibrary
   options.promiseLibrary = this.s.promiseLibrary;
 
@@ -2152,7 +2568,7 @@ Collection.prototype.parallelCollectionScan = function(options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     parallelCollectionScan(self, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -2164,6 +2580,11 @@ var parallelCollectionScan = function(self, options, callback) {
     , numCursors: options.numCursors
   }
 
+  // Do we have a readConcern specified
+  if(self.s.readConcern) {
+    commandObject.readConcern = self.s.readConcern;
+  }
+
   // Execute the command
   self.s.db.command(commandObject, options, function(err, result) {
     if(err) return handleCallback(callback, err, null);
@@ -2188,13 +2609,15 @@ var parallelCollectionScan = function(self, options, callback) {
     }
 
     handleCallback(callback, null, cursors);
-  });  
+  });
 }
 
+define.classMethod('parallelCollectionScan', {callback: true, promise:true});
+
 /**
  * Execute the geoNear command to search for items in the collection
  *
- * @method   
+ * @method
  * @param {number} x Point to search on the x axis, ensure the indexes are ordered in the same order.
  * @param {number} y Point to search on the y axis, ensure the indexes are ordered in the same order.
  * @param {object} [options=null] Optional settings.
@@ -2206,8 +2629,8 @@ var parallelCollectionScan = function(self, options, callback) {
  * @param {object} [options.query=null] Filter the results by a query.
  * @param {boolean} [options.spherical=false] Perform query using a spherical model.
  * @param {boolean} [options.uniqueDocs=false] The closest location in a document to the center of the search region will always be returned MongoDB > 2.X.
- * @param {boolean} [options.includeLocs=false] Include the location data fields in the top level of the results MongoDB > 2.X. 
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {boolean} [options.includeLocs=false] Include the location data fields in the top level of the results MongoDB > 2.X.
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.geoNear = function(x, y, options, callback) {
@@ -2227,7 +2650,7 @@ Collection.prototype.geoNear = function(x, y, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     geoNear(self, x, y, point, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -2245,14 +2668,19 @@ var geoNear = function(self, x, y, point, options, callback) {
   // Exclude readPreference and existing options to prevent user from
   // shooting themselves in the foot
   var exclude = {
-    readPreference: true, 
+    readPreference: true,
     geoNear: true,
-    near: true  
+    near: true
   };
 
   // Filter out any excluded objects
   commandObject = decorateCommand(commandObject, options, exclude);
 
+  // Do we have a readConcern specified
+  if(self.s.readConcern) {
+    commandObject.readConcern = self.s.readConcern;
+  }
+
   // Execute the command
   self.s.db.command(commandObject, options, function (err, res) {
     if(err) return handleCallback(callback, err);
@@ -2260,13 +2688,15 @@ var geoNear = function(self, x, y, point, options, callback) {
     // should we only be returning res.results here? Not sure if the user
     // should see the other return information
     handleCallback(callback, null, res);
-  });  
+  });
 }
 
+define.classMethod('geoNear', {callback: true, promise:true});
+
 /**
  * Execute a geo search using a geo haystack index on a collection.
  *
- * @method   
+ * @method
  * @param {number} x Point to search on the x axis, ensure the indexes are ordered in the same order.
  * @param {number} y Point to search on the y axis, ensure the indexes are ordered in the same order.
  * @param {object} [options=null] Optional settings.
@@ -2274,7 +2704,7 @@ var geoNear = function(self, x, y, point, options, callback) {
  * @param {number} [options.maxDistance=null] Include results up to maxDistance from the point.
  * @param {object} [options.search=null] Filter the results by a query.
  * @param {number} [options.limit=false] Max number of results to return.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.geoHaystackSearch = function(x, y, options, callback) {
@@ -2292,7 +2722,7 @@ Collection.prototype.geoHaystackSearch = function(x, y, options, callback) {
   return new this.s.promiseLibrary(function(resolve, reject) {
     geoHaystackSearch(self, x, y, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -2310,6 +2740,11 @@ var geoHaystackSearch = function(self, x, y, options, callback) {
   // Ensure we have the right read preference inheritance
   options = getReadPreference(self, options, self.s.db, self);
 
+  // Do we have a readConcern specified
+  if(self.s.readConcern) {
+    commandObject.readConcern = self.s.readConcern;
+  }
+
   // Execute the command
   self.s.db.command(commandObject, options, function (err, res) {
     if(err) return handleCallback(callback, err);
@@ -2317,9 +2752,11 @@ var geoHaystackSearch = function(self, x, y, options, callback) {
     // should we only be returning res.results here? Not sure if the user
     // should see the other return information
     handleCallback(callback, null, res);
-  });  
+  });
 }
 
+define.classMethod('geoHaystackSearch', {callback: true, promise:true});
+
 /**
  * Group function helper
  * @ignore
@@ -2355,7 +2792,7 @@ var groupFunction = function () {
 /**
  * Run a group command across a collection
  *
- * @method   
+ * @method
  * @param {(object|array|function|code)} keys An object, array or function expressing the keys to group by.
  * @param {object} condition An optional condition that must be true for a row to be considered.
  * @param {object} initial Initial value of the aggregation counter object.
@@ -2364,7 +2801,7 @@ var groupFunction = function () {
  * @param {boolean} command Specify if you wish to run using the internal group command or using eval, default is true.
  * @param {object} [options=null] Optional settings.
  * @param {(ReadPreference|string)} [options.readPreference=null] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @return {Promise} returns Promise if no callback passed
  */
 Collection.prototype.group = function(keys, condition, initial, reduce, finalize, command, options, callback) {
@@ -2406,7 +2843,7 @@ Collection.prototype.group = function(keys, condition, initial, reduce, finalize
   return new this.s.promiseLibrary(function(resolve, reject) {
     group(self, keys, condition, initial, reduce, finalize, command, options, function(err, r) {
       if(err) return reject(err);
-      resolve(r); 
+      resolve(r);
     });
   });
 }
@@ -2445,6 +2882,12 @@ var group = function(self, keys, condition, initial, reduce, finalize, command,
 
     // Ensure we have the right read preference inheritance
     options = getReadPreference(self, options, self.s.db, self);
+
+    // Do we have a readConcern specified
+    if(self.s.readConcern) {
+      selector.readConcern = self.s.readConcern;
+    }
+
     // Execute command
     self.s.db.command(selector, options, function(err, result) {
       if(err) return handleCallback(callback, err, null);
@@ -2468,9 +2911,11 @@ var group = function(self, keys, condition, initial, reduce, finalize, command,
       if (err) return handleCallback(callback, err, null);
       handleCallback(callback, null, results.result || results);
     });
-  }  
+  }
 }
 
+define.classMethod('group', {callback: true, promise:true});
+
 /**
  * Functions that are passed as scope args must
  * be converted to Code instances.
@@ -2501,7 +2946,7 @@ function processScope (scope) {
 /**
  * Run Map Reduce across a collection. Be aware that the inline option for out will return an array of results not a collection.
  *
- * @method   
+ * @method
  * @param {(function|string)} map The mapping function.
  * @param {(function|string)} reduce The reduce function.
  * @param {object} [options=null] Optional settings.
@@ -2515,7 +2960,8 @@ function processScope (scope) {
  * @param {object} [options.scope=null] Can pass in variables that can be access from map/reduce/finalize.
  * @param {boolean} [options.jsMode=false] It is possible to make the execution stay in JS. Provided in MongoDB > 2.0.X.
  * @param {boolean} [options.verbose=false] Provide statistics on job execution time.
- * @param {Collection~resultCallback} callback The command result callback
+ * @param {boolean} [options.bypassDocumentValidation=false] Allow driver to bypass schema validation in MongoDB 3.2 or higher.
+ * @param {Collection~resultCallback} [callback] The command result callback
  * @throws {MongoError}
  * @return {Promise} returns Promise if no callback passed
  */
@@ -2547,7 +2993,7 @@ Collection.prototype.mapReduce = function(map, reduce, options, callback) {
     mapReduce(self, map, reduce, options, function(err, r, r1) {
       if(err) return reject(err);
       if(r instanceof Collection) return resolve(r);
-      resolve({results: r, stats: r1}); 
+      resolve({results: r, stats: r1});
     });
   });
 }
@@ -2572,9 +3018,16 @@ var mapReduce = function(self, map, reduce, options, callback) {
   options = getReadPreference(self, options, self.s.db, self);
 
   // If we have a read preference and inline is not set as output fail hard
-  if((options.readPreference != false && options.readPreference != 'primary') 
+  if((options.readPreference != false && options.readPreference != 'primary')
     && options['out'] && (options['out'].inline != 1 && options['out'] != 'inline')) {
-      options.readPreference = 'primary';    
+      options.readPreference = 'primary';
+  } else if(self.s.readConcern) {
+    mapCommandHash.readConcern = self.s.readConcern;
+  }
+
+  // Is bypassDocumentValidation specified
+  if(typeof options.bypassDocumentValidation == 'boolean') {
+    mapCommandHash.bypassDocumentValidation = options.bypassDocumentValidation;
   }
 
   // Execute command
@@ -2597,7 +3050,7 @@ var mapReduce = function(self, map, reduce, options, callback) {
       if(options['verbose'] == null || !options['verbose']) {
         return handleCallback(callback, null, result.results);
       }
-      
+
       return handleCallback(callback, null, result.results, stats);
     }
 
@@ -2623,10 +3076,12 @@ var mapReduce = function(self, map, reduce, options, callback) {
   });
 }
 
+define.classMethod('mapReduce', {callback: true, promise:true});
+
 /**
  * Initiate a Out of order batch write operation. All operations will be buffered into insert/update/remove commands executed out of order.
  *
- * @method   
+ * @method
  * @param {object} [options=null] Optional settings.
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
@@ -2639,10 +3094,12 @@ Collection.prototype.initializeUnorderedBulkOp = function(options) {
   return unordered(this.s.topology, this, options);
 }
 
+define.classMethod('initializeUnorderedBulkOp', {callback: false, promise:false, returns: [ordered.UnorderedBulkOperation]});
+
 /**
  * Initiate an In order bulk write operation, operations will be serially executed in the order they are added, creating a new operation for each switch in types.
  *
- * @method   
+ * @method
  * @param {object} [options=null] Optional settings.
  * @param {(number|string)} [options.w=null] The write concern.
  * @param {number} [options.wtimeout=null] The write concern timeout.
@@ -2656,6 +3113,8 @@ Collection.prototype.initializeOrderedBulkOp = function(options) {
   return ordered(this.s.topology, this, options);
 }
 
+define.classMethod('initializeOrderedBulkOp', {callback: false, promise:false, returns: [ordered.OrderedBulkOperation]});
+
 // Get write concern
 var writeConcern = function(target, db, col, options) {
   if(options.w != null || options.j != null || options.fsync != null) {
@@ -2665,7 +3124,7 @@ var writeConcern = function(target, db, col, options) {
     if(options.j != null) opts.j = options.j;
     if(options.fsync != null) opts.fsync = options.fsync;
     target.writeConcern = opts;
-  } else if(col.writeConcern.w != null || col.writeConcern.j != null || col.writeConcern.fsync != null) {      
+  } else if(col.writeConcern.w != null || col.writeConcern.j != null || col.writeConcern.fsync != null) {
     target.writeConcern = col.writeConcern;
   } else if(db.writeConcern.w != null || db.writeConcern.j != null || db.writeConcern.fsync != null) {
     target.writeConcern = db.writeConcern;
@@ -2685,7 +3144,7 @@ var getReadPreference = function(self, options, db, coll) {
     r = db.readPreference;
   }
 
-  if(r instanceof ReadPreference) {      
+  if(r instanceof ReadPreference) {
     options.readPreference = new CoreReadPreference(r.mode, r.tags);
   } else if(typeof r == 'string') {
     options.readPreference = new CoreReadPreference(r);