mongodb 3.6.9 → 3.7.0

package/README.md

@@ -15,10 +15,10 @@ Check out our [beta version 4.0 here](https://github.com/mongodb/node-mongodb-na
 
 | what          | where                                                |
 | ------------- | ---------------------------------------------------- |
-| documentation | http://mongodb.github.io/node-mongodb-native         |
-| api-doc       | http://mongodb.github.io/node-mongodb-native/3.6/api |
+| documentation | https://mongodb.github.io/node-mongodb-native         |
+| api-doc       | https://mongodb.github.io/node-mongodb-native/3.6/api |
 | source        | https://github.com/mongodb/node-mongodb-native       |
-| mongodb       | http://www.mongodb.org                               |
+| mongodb       | https://www.mongodb.org                               |
 
 ### Bugs / Feature Requests
 
@@ -481,7 +481,7 @@ For more detailed information, see the [tutorials](docs/reference/content/tutori
 
 ## Next Steps
 
-- [MongoDB Documentation](http://mongodb.org)
+- [MongoDB Documentation](https://mongodb.org)
 - [Read about Schemas](http://learnmongodbthehardway.com)
 - [Star us on GitHub](https://github.com/mongodb/node-mongodb-native)
 

package/index.js

@@ -17,6 +17,9 @@ connect.MongoWriteConcernError = core.MongoWriteConcernError;
 connect.MongoBulkWriteError = require('./lib/bulk/common').BulkWriteError;
 connect.BulkWriteError = connect.MongoBulkWriteError;
 
+// Expose server versions
+connect.ServerApiVersion = core.ServerApiVersion;
+
 // Actual driver classes exported
 connect.Admin = require('./lib/admin');
 connect.MongoClient = require('./lib/mongo_client');
@@ -47,6 +50,7 @@ connect.Int32 = core.BSON.Int32;
 connect.Long = core.BSON.Long;
 connect.MinKey = core.BSON.MinKey;
 connect.MaxKey = core.BSON.MaxKey;
+/** @deprecated Please use `ObjectId` */
 connect.ObjectID = core.BSON.ObjectID;
 connect.ObjectId = core.BSON.ObjectID;
 connect.Symbol = core.BSON.Symbol;

package/lib/bulk/common.js

@@ -1176,8 +1176,11 @@ class BulkOperationBase {
    * @param {function} callback
    */
   bulkExecute(_writeConcern, options, callback) {
-    if (typeof options === 'function') (callback = options), (options = {});
-    options = options || {};
+    if (typeof options === 'function') {
+      callback = options;
+    }
+
+    const finalOptions = Object.assign({}, this.s.options, options);
 
     if (typeof _writeConcern === 'function') {
       callback = _writeConcern;
@@ -1203,7 +1206,7 @@ class BulkOperationBase {
       const emptyBatchError = toError('Invalid Operation, no operations specified');
       return this._handleEarlyError(emptyBatchError, callback);
     }
-    return { options, callback };
+    return { options: finalOptions, callback };
   }
 
   /**

package/lib/cmap/connection.js

@@ -37,6 +37,8 @@ class Connection extends EventEmitter {
     this.port = options.port || 27017;
     this.monitorCommands =
       typeof options.monitorCommands === 'boolean' ? options.monitorCommands : false;
+    this.serverApi = options.serverApi;
+
     this.closed = false;
     this.destroyed = false;
 
@@ -170,33 +172,58 @@ class Connection extends EventEmitter {
     });
   }
 
+  applyApiVersion(options) {
+    if (this.serverApi) {
+      options.serverApi = this.serverApi;
+    }
+    return options;
+  }
+
   // Wire protocol methods
   command(ns, cmd, options, callback) {
-    wp.command(makeServerTrampoline(this), ns, cmd, options, callback);
+    if (typeof options === 'function') {
+      callback = options;
+      options = {};
+    }
+    wp.command(makeServerTrampoline(this), ns, cmd, this.applyApiVersion(options), callback);
   }
 
   query(ns, cmd, cursorState, options, callback) {
-    wp.query(makeServerTrampoline(this), ns, cmd, cursorState, options, callback);
+    wp.query(
+      makeServerTrampoline(this),
+      ns,
+      cmd,
+      cursorState,
+      this.applyApiVersion(options),
+      callback
+    );
   }
 
   getMore(ns, cursorState, batchSize, options, callback) {
-    wp.getMore(makeServerTrampoline(this), ns, cursorState, batchSize, options, callback);
+    wp.getMore(
+      makeServerTrampoline(this),
+      ns,
+      cursorState,
+      batchSize,
+      this.applyApiVersion(options),
+      callback
+    );
   }
 
   killCursors(ns, cursorState, callback) {
-    wp.killCursors(makeServerTrampoline(this), ns, cursorState, callback);
+    wp.killCursors(makeServerTrampoline(this), ns, cursorState, this.applyApiVersion({}), callback);
   }
 
   insert(ns, ops, options, callback) {
-    wp.insert(makeServerTrampoline(this), ns, ops, options, callback);
+    wp.insert(makeServerTrampoline(this), ns, ops, this.applyApiVersion(options), callback);
   }
 
   update(ns, ops, options, callback) {
-    wp.update(makeServerTrampoline(this), ns, ops, options, callback);
+    wp.update(makeServerTrampoline(this), ns, ops, this.applyApiVersion(options), callback);
   }
 
   remove(ns, ops, options, callback) {
-    wp.remove(makeServerTrampoline(this), ns, ops, options, callback);
+    wp.remove(makeServerTrampoline(this), ns, ops, this.applyApiVersion(options), callback);
   }
 }
 
@@ -317,6 +344,7 @@ function write(command, options, callback) {
     promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,
     promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
     promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
+    bsonRegExp: typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : false,
     raw: typeof options.raw === 'boolean' ? options.raw : false
   };
 

package/lib/cmap/connection_pool.js

@@ -41,6 +41,7 @@ const VALID_POOL_OPTIONS = new Set([
   'ssl',
   'bson',
   'connectionType',
+  'serverApi',
   'monitorCommands',
   'socketTimeout',
   'credentials',

package/lib/collection.js

@@ -120,6 +120,8 @@ function Collection(db, topology, dbName, name, pkFactory, options) {
     options == null || options.promoteBuffers == null
       ? db.s.options.promoteBuffers
       : options.promoteBuffers;
+  const bsonRegExp =
+    options == null || options.bsonRegExp == null ? db.s.options.bsonRegExp : options.bsonRegExp;
   const collectionHint = null;
 
   const namespace = new MongoDBNamespace(dbName, name);
@@ -156,6 +158,8 @@ function Collection(db, topology, dbName, name, pkFactory, options) {
     promoteValues: promoteValues,
     // promoteBuffers
     promoteBuffers: promoteBuffers,
+    // bsonRegExp
+    bsonRegExp: bsonRegExp,
     // internalHint
     internalHint: internalHint,
     // collectionHint
@@ -303,6 +307,7 @@ const DEPRECATED_FIND_OPTIONS = ['maxScan', 'fields', 'snapshot', 'oplogReplay']
  * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
  * @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
  * @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
+ * @param {boolean} [options.bsonRegExp=false] By default, regex returned from MDB will be native to the language. Setting to true will ensure that a BSON.BSONRegExp object is returned.
  * @param {(ReadPreference|string)} [options.readPreference] 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] Number of milliseconds to wait before aborting the query.
@@ -451,6 +456,8 @@ Collection.prototype.find = deprecateOptions(
       newOptions.promoteValues = this.s.promoteValues;
     if (newOptions.promoteBuffers == null && typeof this.s.promoteBuffers === 'boolean')
       newOptions.promoteBuffers = this.s.promoteBuffers;
+    if (newOptions.bsonRegExp == null && typeof this.s.bsonRegExp === 'boolean')
+      newOptions.bsonRegExp = this.s.bsonRegExp;
 
     // Sort options
     if (findCommand.sort) {
@@ -1075,6 +1082,7 @@ Collection.prototype.save = deprecate(function(doc, options, callback) {
  * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
  * @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
  * @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
+ * @param {boolean} [options.bsonRegExp=false] By default, regex returned from MDB will be native to the language. Setting to true will ensure that a BSON.BSONRegExp object is returned.
  * @param {(ReadPreference|string)} [options.readPreference] 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] Number of milliseconds to wait before aborting the query.
@@ -1524,7 +1532,7 @@ Collection.prototype.count = deprecate(function(query, options, callback) {
 
   return executeOperation(
     this.s.topology,
-    new EstimatedDocumentCountOperation(this, query, options),
+    new EstimatedDocumentCountOperation(this, Object.assign({ query }, options)),
     callback
   );
 }, 'collection.count is deprecated, and will be removed in a future version.' +
@@ -1899,6 +1907,7 @@ Collection.prototype.findAndRemove = deprecate(function(query, sort, options, ca
  * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
  * @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
  * @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
+ * @param {boolean} [options.bsonRegExp=false] By default, regex returned from MDB will be native to the language. Setting to true will ensure that a BSON.BSONRegExp object is returned.
  * @param {object} [options.collation] Specify collation settings for operation. See {@link https://docs.mongodb.com/manual/reference/command/aggregate|aggregation documentation}.
  * @param {string} [options.comment] Add a comment to an aggregation command
  * @param {string|object} [options.hint] Add an index selection hint to an aggregation command

package/lib/command_utils.js

@@ -0,0 +1,124 @@
+'use strict';
+const Msg = require('./core/connection/msg').Msg;
+const KillCursor = require('./core/connection/commands').KillCursor;
+const GetMore = require('./core/connection/commands').GetMore;
+const deepCopy = require('./utils').deepCopy;
+
+/** Commands that we want to redact because of the sensitive nature of their contents */
+const SENSITIVE_COMMANDS = new Set([
+  'authenticate',
+  'saslStart',
+  'saslContinue',
+  'getnonce',
+  'createUser',
+  'updateUser',
+  'copydbgetnonce',
+  'copydbsaslstart',
+  'copydb'
+]);
+
+const HELLO_COMMANDS = new Set(['hello', 'ismaster', 'isMaster']);
+
+const LEGACY_FIND_QUERY_MAP = {
+  $query: 'filter',
+  $orderby: 'sort',
+  $hint: 'hint',
+  $comment: 'comment',
+  $maxScan: 'maxScan',
+  $max: 'max',
+  $min: 'min',
+  $returnKey: 'returnKey',
+  $showDiskLoc: 'showRecordId',
+  $maxTimeMS: 'maxTimeMS',
+  $snapshot: 'snapshot'
+};
+
+const LEGACY_FIND_OPTIONS_MAP = {
+  numberToSkip: 'skip',
+  numberToReturn: 'batchSize',
+  returnFieldsSelector: 'projection'
+};
+
+const OP_QUERY_KEYS = [
+  'tailable',
+  'oplogReplay',
+  'noCursorTimeout',
+  'awaitData',
+  'partial',
+  'exhaust'
+];
+
+const collectionName = command => command.ns.split('.')[1];
+
+const shouldRedactCommand = (commandName, cmd) =>
+  SENSITIVE_COMMANDS.has(commandName) ||
+  (HELLO_COMMANDS.has(commandName) && !!cmd.speculativeAuthenticate);
+
+/**
+ * Extract the actual command from the query, possibly upconverting if it's a legacy
+ * format
+ *
+ * @param {Object} command the command
+ */
+const extractCommand = command => {
+  let extractedCommand;
+  if (command instanceof GetMore) {
+    extractedCommand = {
+      getMore: deepCopy(command.cursorId),
+      collection: collectionName(command),
+      batchSize: command.numberToReturn
+    };
+  } else if (command instanceof KillCursor) {
+    extractedCommand = {
+      killCursors: collectionName(command),
+      cursors: deepCopy(command.cursorIds)
+    };
+  } else if (command instanceof Msg) {
+    extractedCommand = deepCopy(command.command);
+  } else if (command.query && command.query.$query) {
+    let result;
+    if (command.ns === 'admin.$cmd') {
+      // upconvert legacy command
+      result = Object.assign({}, command.query.$query);
+    } else {
+      // upconvert legacy find command
+      result = { find: collectionName(command) };
+      Object.keys(LEGACY_FIND_QUERY_MAP).forEach(key => {
+        if (typeof command.query[key] !== 'undefined')
+          result[LEGACY_FIND_QUERY_MAP[key]] = deepCopy(command.query[key]);
+      });
+    }
+
+    Object.keys(LEGACY_FIND_OPTIONS_MAP).forEach(key => {
+      if (typeof command[key] !== 'undefined')
+        result[LEGACY_FIND_OPTIONS_MAP[key]] = deepCopy(command[key]);
+    });
+
+    OP_QUERY_KEYS.forEach(key => {
+      if (command[key]) result[key] = command[key];
+    });
+
+    if (typeof command.pre32Limit !== 'undefined') {
+      result.limit = command.pre32Limit;
+    }
+
+    if (command.query.$explain) {
+      extractedCommand = { explain: result };
+    } else {
+      extractedCommand = result;
+    }
+  } else {
+    extractedCommand = deepCopy(command.query || command);
+  }
+
+  const commandName = Object.keys(extractedCommand)[0];
+  return {
+    cmd: extractedCommand,
+    name: commandName,
+    shouldRedact: shouldRedactCommand(commandName, extractedCommand)
+  };
+};
+
+module.exports = {
+  extractCommand
+};

package/lib/core/auth/mongo_credentials.js

@@ -58,7 +58,10 @@ class MongoCredentials {
         this.password = process.env.AWS_SECRET_ACCESS_KEY;
       }
 
-      if (!this.mechanismProperties.AWS_SESSION_TOKEN && process.env.AWS_SESSION_TOKEN) {
+      if (
+        this.mechanismProperties.AWS_SESSION_TOKEN == null &&
+        process.env.AWS_SESSION_TOKEN != null
+      ) {
         this.mechanismProperties.AWS_SESSION_TOKEN = process.env.AWS_SESSION_TOKEN;
       }
     }

package/lib/core/auth/mongodb_aws.js

@@ -9,6 +9,7 @@ const url = require('url');
 
 let aws4;
 try {
+  // Ensure you always wrap an optional require in the try block NODE-3199
   aws4 = require('aws4');
 } catch (e) {
   // don't do anything;
@@ -50,12 +51,21 @@ class MongoDBAWS extends AuthProvider {
       return;
     }
 
-    const username = credentials.username;
-    const password = credentials.password;
     const db = credentials.source;
-    const token = credentials.mechanismProperties.AWS_SESSION_TOKEN;
     const bson = this.bson;
 
+    const accessKeyId = credentials.username;
+    const secretAccessKey = credentials.password;
+    const sessionToken = credentials.mechanismProperties.AWS_SESSION_TOKEN;
+
+    // If all three defined, include sessionToken, else include username and pass, else no credentials
+    const awsCredentials =
+      accessKeyId && secretAccessKey && sessionToken
+        ? { accessKeyId, secretAccessKey, sessionToken }
+        : accessKeyId && secretAccessKey
+        ? { accessKeyId, secretAccessKey }
+        : undefined;
+
     crypto.randomBytes(32, (err, nonce) => {
       if (err) {
         callback(err);
@@ -108,18 +118,14 @@ class MongoDBAWS extends AuthProvider {
             path: '/',
             body
           },
-          {
-            accessKeyId: username,
-            secretAccessKey: password,
-            token
-          }
+          awsCredentials
         );
 
         const authorization = options.headers.Authorization;
         const date = options.headers['X-Amz-Date'];
         const payload = { a: authorization, d: date };
-        if (token) {
-          payload.t = token;
+        if (sessionToken) {
+          payload.t = sessionToken;
         }
 
         const saslContinue = {
@@ -163,6 +169,7 @@ function makeTempCredentials(credentials, callback) {
   if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
     request(
       `${AWS_RELATIVE_URI}${process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}`,
+      undefined,
       (err, res) => {
         if (err) return callback(err);
         done(res);
@@ -214,11 +221,6 @@ function deriveRegion(host) {
 }
 
 function request(uri, options, callback) {
-  if (typeof options === 'function') {
-    callback = options;
-    options = {};
-  }
-
   options = Object.assign(
     {
       method: 'GET',

package/lib/core/auth/scram.js

@@ -11,6 +11,7 @@ const Binary = BSON.Binary;
 
 let saslprep;
 try {
+  // Ensure you always wrap an optional require in the try block NODE-3199
   saslprep = require('saslprep');
 } catch (e) {
   // don't do anything;

package/lib/core/connection/apm.js

@@ -1,123 +1,16 @@
 'use strict';
-const Msg = require('../connection/msg').Msg;
 const KillCursor = require('../connection/commands').KillCursor;
 const GetMore = require('../connection/commands').GetMore;
 const calculateDurationInMs = require('../../utils').calculateDurationInMs;
-
-/** Commands that we want to redact because of the sensitive nature of their contents */
-const SENSITIVE_COMMANDS = new Set([
-  'authenticate',
-  'saslStart',
-  'saslContinue',
-  'getnonce',
-  'createUser',
-  'updateUser',
-  'copydbgetnonce',
-  'copydbsaslstart',
-  'copydb'
-]);
+const extractCommand = require('../../command_utils').extractCommand;
 
 // helper methods
-const extractCommandName = commandDoc => Object.keys(commandDoc)[0];
 const namespace = command => command.ns;
 const databaseName = command => command.ns.split('.')[0];
-const collectionName = command => command.ns.split('.')[1];
 const generateConnectionId = pool =>
   pool.options ? `${pool.options.host}:${pool.options.port}` : pool.address;
-const maybeRedact = (commandName, result) => (SENSITIVE_COMMANDS.has(commandName) ? {} : result);
 const isLegacyPool = pool => pool.s && pool.queue;
 
-const LEGACY_FIND_QUERY_MAP = {
-  $query: 'filter',
-  $orderby: 'sort',
-  $hint: 'hint',
-  $comment: 'comment',
-  $maxScan: 'maxScan',
-  $max: 'max',
-  $min: 'min',
-  $returnKey: 'returnKey',
-  $showDiskLoc: 'showRecordId',
-  $maxTimeMS: 'maxTimeMS',
-  $snapshot: 'snapshot'
-};
-
-const LEGACY_FIND_OPTIONS_MAP = {
-  numberToSkip: 'skip',
-  numberToReturn: 'batchSize',
-  returnFieldsSelector: 'projection'
-};
-
-const OP_QUERY_KEYS = [
-  'tailable',
-  'oplogReplay',
-  'noCursorTimeout',
-  'awaitData',
-  'partial',
-  'exhaust'
-];
-
-/**
- * Extract the actual command from the query, possibly upconverting if it's a legacy
- * format
- *
- * @param {Object} command the command
- */
-const extractCommand = command => {
-  if (command instanceof GetMore) {
-    return {
-      getMore: command.cursorId,
-      collection: collectionName(command),
-      batchSize: command.numberToReturn
-    };
-  }
-
-  if (command instanceof KillCursor) {
-    return {
-      killCursors: collectionName(command),
-      cursors: command.cursorIds
-    };
-  }
-
-  if (command instanceof Msg) {
-    return command.command;
-  }
-
-  if (command.query && command.query.$query) {
-    let result;
-    if (command.ns === 'admin.$cmd') {
-      // upconvert legacy command
-      result = Object.assign({}, command.query.$query);
-    } else {
-      // upconvert legacy find command
-      result = { find: collectionName(command) };
-      Object.keys(LEGACY_FIND_QUERY_MAP).forEach(key => {
-        if (typeof command.query[key] !== 'undefined')
-          result[LEGACY_FIND_QUERY_MAP[key]] = command.query[key];
-      });
-    }
-
-    Object.keys(LEGACY_FIND_OPTIONS_MAP).forEach(key => {
-      if (typeof command[key] !== 'undefined') result[LEGACY_FIND_OPTIONS_MAP[key]] = command[key];
-    });
-
-    OP_QUERY_KEYS.forEach(key => {
-      if (command[key]) result[key] = command[key];
-    });
-
-    if (typeof command.pre32Limit !== 'undefined') {
-      result.limit = command.pre32Limit;
-    }
-
-    if (command.query.$explain) {
-      return { explain: result };
-    }
-
-    return result;
-  }
-
-  return command.query ? command.query : command;
-};
-
 const extractReply = (command, reply) => {
   if (command instanceof GetMore) {
     return {
@@ -177,21 +70,15 @@ class CommandStartedEvent {
    * @param {Object} command the command
    */
   constructor(pool, command) {
-    const cmd = extractCommand(command);
-    const commandName = extractCommandName(cmd);
+    const extractedCommand = extractCommand(command);
+    const commandName = extractedCommand.name;
     const connectionDetails = extractConnectionDetails(pool);
 
-    // NOTE: remove in major revision, this is not spec behavior
-    if (SENSITIVE_COMMANDS.has(commandName)) {
-      this.commandObj = {};
-      this.commandObj[commandName] = true;
-    }
-
     Object.assign(this, connectionDetails, {
       requestId: command.requestId,
       databaseName: databaseName(command),
       commandName,
-      command: cmd
+      command: extractedCommand.shouldRedact ? {} : extractedCommand.cmd
     });
   }
 }
@@ -207,15 +94,15 @@ class CommandSucceededEvent {
    * @param {Array} started a high resolution tuple timestamp of when the command was first sent, to calculate duration
    */
   constructor(pool, command, reply, started) {
-    const cmd = extractCommand(command);
-    const commandName = extractCommandName(cmd);
+    const extractedCommand = extractCommand(command);
+    const commandName = extractedCommand.name;
     const connectionDetails = extractConnectionDetails(pool);
 
     Object.assign(this, connectionDetails, {
       requestId: command.requestId,
       commandName,
       duration: calculateDurationInMs(started),
-      reply: maybeRedact(commandName, extractReply(command, reply))
+      reply: extractedCommand.shouldRedact ? {} : extractReply(command, reply)
     });
   }
 }
@@ -231,15 +118,15 @@ class CommandFailedEvent {
    * @param {Array} started a high resolution tuple timestamp of when the command was first sent, to calculate duration
    */
   constructor(pool, command, error, started) {
-    const cmd = extractCommand(command);
-    const commandName = extractCommandName(cmd);
+    const extractedCommand = extractCommand(command);
+    const commandName = extractedCommand.name;
     const connectionDetails = extractConnectionDetails(pool);
 
     Object.assign(this, connectionDetails, {
       requestId: command.requestId,
       commandName,
       duration: calculateDurationInMs(started),
-      failure: maybeRedact(commandName, error)
+      failure: extractedCommand.shouldRedact ? {} : error
     });
   }
 }

package/lib/core/connection/commands.js

@@ -398,7 +398,12 @@ KillCursor.prototype.toBin = function() {
 };
 
 var Response = function(bson, message, msgHeader, msgBody, opts) {
-  opts = opts || { promoteLongs: true, promoteValues: true, promoteBuffers: false };
+  opts = opts || {
+    promoteLongs: true,
+    promoteValues: true,
+    promoteBuffers: false,
+    bsonRegExp: false
+  };
   this.parsed = false;
   this.raw = message;
   this.data = msgBody;
@@ -429,6 +434,7 @@ var Response = function(bson, message, msgHeader, msgBody, opts) {
   this.promoteLongs = typeof opts.promoteLongs === 'boolean' ? opts.promoteLongs : true;
   this.promoteValues = typeof opts.promoteValues === 'boolean' ? opts.promoteValues : true;
   this.promoteBuffers = typeof opts.promoteBuffers === 'boolean' ? opts.promoteBuffers : false;
+  this.bsonRegExp = typeof opts.bsonRegExp === 'boolean' ? opts.bsonRegExp : false;
 };
 
 Response.prototype.isParsed = function() {
@@ -449,13 +455,16 @@ Response.prototype.parse = function(options) {
     typeof options.promoteValues === 'boolean' ? options.promoteValues : this.opts.promoteValues;
   var promoteBuffers =
     typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : this.opts.promoteBuffers;
+  var bsonRegExp =
+    typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : this.opts.bsonRegExp;
   var bsonSize, _options;
 
   // Set up the options
   _options = {
     promoteLongs: promoteLongs,
     promoteValues: promoteValues,
-    promoteBuffers: promoteBuffers
+    promoteBuffers: promoteBuffers,
+    bsonRegExp: bsonRegExp
   };
 
   // Position within OP_REPLY at which documents start