mongodb 3.6.8 → 3.6.12

package/lib/core/connection/msg.js

@@ -139,7 +139,12 @@ Msg.getRequestId = function() {
 
 class BinMsg {
   constructor(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;
@@ -161,6 +166,7 @@ class BinMsg {
     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;
 
     this.documents = [];
   }
@@ -186,12 +192,15 @@ class BinMsg {
       typeof options.promoteBuffers === 'boolean'
         ? options.promoteBuffers
         : this.opts.promoteBuffers;
+    const bsonRegExp =
+      typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : this.opts.bsonRegExp;
 
     // Set up the options
     const _options = {
       promoteLongs: promoteLongs,
       promoteValues: promoteValues,
-      promoteBuffers: promoteBuffers
+      promoteBuffers: promoteBuffers,
+      bsonRegExp: bsonRegExp
     };
 
     while (this.index < this.data.length) {

package/lib/core/connection/pool.js

@@ -76,6 +76,7 @@ var _id = 0;
  * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
  * @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 {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.
  * @fires Pool#connect
  * @fires Pool#close
@@ -127,6 +128,7 @@ var Pool = function(topology, options) {
       promoteLongs: true,
       promoteValues: true,
       promoteBuffers: false,
+      bsonRegExp: false,
       // Reconnection options
       reconnect: true,
       reconnectInterval: 1000,
@@ -390,8 +392,8 @@ function messageHandler(self) {
     if (self.logger.isDebug()) {
       self.logger.debug(
         f(
-          'message [%s] received from %s:%s',
-          message.raw.toString('hex'),
+          'message [ %s ] received from %s:%s',
+          message.raw.length,
           self.options.host,
           self.options.port
         )
@@ -602,6 +604,7 @@ Pool.prototype.logout = function(dbName, callback) {
 /**
  * Unref the pool
  * @method
+ * @deprecated This function is deprecated and will be removed in the next major version.
  */
 Pool.prototype.unref = function() {
   // Get all the known connections
@@ -870,6 +873,7 @@ Pool.prototype.write = function(command, options, cb) {
     promoteLongs: true,
     promoteValues: true,
     promoteBuffers: false,
+    bsonRegExp: false,
     fullResult: false
   };
 
@@ -879,6 +883,7 @@ Pool.prototype.write = function(command, options, cb) {
     typeof options.promoteValues === 'boolean' ? options.promoteValues : true;
   operation.promoteBuffers =
     typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false;
+  operation.bsonRegExp = typeof options.bsonRegExp === 'boolean' ? options.bsonRegExp : false;
   operation.raw = typeof options.raw === 'boolean' ? options.raw : false;
   operation.immediateRelease =
     typeof options.immediateRelease === 'boolean' ? options.immediateRelease : false;

package/lib/core/connection/utils.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const parsePackageVersion = require('../../utils').parsePackageVersion;
+const MongoError = require('../error').MongoError;
+
 const require_optional = require('optional-require')(require);
 
 function debugOptions(debugFields, options) {
@@ -16,7 +19,15 @@ function retrieveBSON() {
   BSON.native = false;
 
   const optionalBSON = require_optional('bson-ext');
+  const bsonExtVersion = parsePackageVersion(
+    require_optional('bson-ext/package.json') || { version: '0.0.0' }
+  );
   if (optionalBSON) {
+    if (bsonExtVersion.major >= 4) {
+      throw new MongoError(
+        'bson-ext version 4 and above does not work with the 3.x version of the mongodb driver'
+      );
+    }
     optionalBSON.native = true;
     return optionalBSON;
   }
@@ -31,21 +42,43 @@ function noSnappyWarning() {
   );
 }
 
+const PKG_VERSION = Symbol('kPkgVersion');
+
 // Facilitate loading Snappy optionally
 function retrieveSnappy() {
-  let snappy = require_optional('snappy');
+  const snappy = require_optional('snappy');
   if (!snappy) {
-    snappy = {
+    return {
       compress: noSnappyWarning,
       uncompress: noSnappyWarning,
       compressSync: noSnappyWarning,
       uncompressSync: noSnappyWarning
     };
   }
+
+  const snappyPkg = require_optional('snappy/package.json') || { version: '0.0.0' };
+  const version = parsePackageVersion(snappyPkg);
+  snappy[PKG_VERSION] = version;
+  if (version.major >= 7) {
+    const compressOriginal = snappy.compress;
+    const uncompressOriginal = snappy.uncompress;
+    snappy.compress = (data, callback) => {
+      compressOriginal(data)
+        .then(res => callback(undefined, res))
+        .catch(error => callback(error));
+    };
+    snappy.uncompress = (data, callback) => {
+      uncompressOriginal(data)
+        .then(res => callback(undefined, res))
+        .catch(error => callback(error));
+    };
+  }
+
   return snappy;
 }
 
 module.exports = {
+  PKG_VERSION,
   debugOptions,
   retrieveBSON,
   retrieveSnappy

package/lib/core/cursor.js

@@ -146,6 +146,13 @@ class CoreCursor extends Readable {
       this.cursorState.promoteBuffers = options.promoteBuffers;
     }
 
+    // Add bsonRegExp to cursor state
+    if (typeof topologyOptions.bsonRegExp === 'boolean') {
+      this.cursorState.bsonRegExp = topologyOptions.bsonRegExp;
+    } else if (typeof options.bsonRegExp === 'boolean') {
+      this.cursorState.bsonRegExp = options.bsonRegExp;
+    }
+
     if (topologyOptions.reconnect) {
       this.cursorState.reconnect = topologyOptions.reconnect;
     }

package/lib/core/index.js

@@ -5,6 +5,7 @@ const require_optional = require('optional-require')(require);
 const EJSON = require('./utils').retrieveEJSON();
 
 try {
+  // Ensure you always wrap an optional require in the try block NODE-3199
   // Attempt to grab the native BSON parser
   const BSONNative = require_optional('bson-ext');
   // If we got the native parser, use it instead of the

package/lib/core/sdam/monitor.js

@@ -85,7 +85,8 @@ class Monitor extends EventEmitter {
         raw: false,
         promoteLongs: true,
         promoteValues: true,
-        promoteBuffers: true
+        promoteBuffers: true,
+        bsonRegExp: true
       }
     );
 

package/lib/core/sdam/server.js

@@ -20,6 +20,7 @@ const isNodeShuttingDownError = require('../error').isNodeShuttingDownError;
 const isNetworkErrorBeforeHandshake = require('../error').isNetworkErrorBeforeHandshake;
 const maxWireVersion = require('../utils').maxWireVersion;
 const makeStateMachine = require('../utils').makeStateMachine;
+const extractCommand = require('../../command_utils').extractCommand;
 const common = require('./common');
 const ServerType = common.ServerType;
 const isTransactionCommand = require('../transactions').isTransactionCommand;
@@ -49,6 +50,7 @@ const DEBUG_FIELDS = [
   'promoteLongs',
   'promoteValues',
   'promoteBuffers',
+  'bsonRegExp',
   'servername'
 ];
 
@@ -166,6 +168,10 @@ class Server extends EventEmitter {
     return this.s.description;
   }
 
+  get supportsRetryableWrites() {
+    return supportsRetryableWrites(this);
+  }
+
   get name() {
     return this.s.description.address;
   }
@@ -261,10 +267,11 @@ class Server extends EventEmitter {
 
     // Debug log
     if (this.s.logger.isDebug()) {
+      const extractedCommand = extractCommand(cmd);
       this.s.logger.debug(
         `executing command [${JSON.stringify({
           ns,
-          cmd,
+          cmd: extractedCommand.shouldRedact ? `${extractedCommand.name} details REDACTED` : cmd,
           options: debugOptions(DEBUG_FIELDS, options)
         })}] against ${this.name}`
       );

package/lib/core/sdam/topology.js

@@ -9,7 +9,6 @@ const events = require('./events');
 const Server = require('./server').Server;
 const relayEvents = require('../utils').relayEvents;
 const ReadPreference = require('../topologies/read_preference');
-const isRetryableWritesSupported = require('../topologies/shared').isRetryableWritesSupported;
 const CoreCursor = require('../cursor').CoreCursor;
 const deprecate = require('util').deprecate;
 const BSON = require('../connection/utils').retrieveBSON();
@@ -669,12 +668,17 @@ class Topology extends EventEmitter {
         return;
       }
 
+      const notAlreadyRetrying = !options.retrying;
+      const retryWrites = !!options.retryWrites;
+      const hasSession = !!options.session;
+      const supportsRetryableWrites = server.supportsRetryableWrites;
+      const notInTransaction = !hasSession || !options.session.inTransaction();
       const willRetryWrite =
-        !options.retrying &&
-        !!options.retryWrites &&
-        options.session &&
-        isRetryableWritesSupported(this) &&
-        !options.session.inTransaction() &&
+        notAlreadyRetrying &&
+        retryWrites &&
+        hasSession &&
+        supportsRetryableWrites &&
+        notInTransaction &&
         isWriteCommand(cmd);
 
       const cb = (err, result) => {
@@ -738,8 +742,11 @@ class Topology extends EventEmitter {
     return this.s.state === STATE_CLOSED;
   }
 
+  /**
+   * @deprecated This function is deprecated and will be removed in the next major version.
+   */
   unref() {
-    emitWarning('not implemented: `unref`');
+    emitWarning('`unref` is a noop and will be removed in the next major version');
   }
 
   // NOTE: There are many places in code where we explicitly check the last isMaster
@@ -925,20 +932,26 @@ function executeWriteOperation(args, options, callback) {
   const ns = args.ns;
   const ops = args.ops;
 
-  const willRetryWrite =
-    !args.retrying &&
-    !!options.retryWrites &&
-    options.session &&
-    isRetryableWritesSupported(topology) &&
-    !options.session.inTransaction() &&
-    options.explain === undefined;
-
   topology.selectServer(writableServerSelector(), options, (err, server) => {
     if (err) {
       callback(err, null);
       return;
     }
 
+    const notAlreadyRetrying = !args.retrying;
+    const retryWrites = !!options.retryWrites;
+    const hasSession = !!options.session;
+    const supportsRetryableWrites = server.supportsRetryableWrites;
+    const notInTransaction = !hasSession || !options.session.inTransaction();
+    const notExplaining = options.explain === undefined;
+    const willRetryWrite =
+      notAlreadyRetrying &&
+      retryWrites &&
+      hasSession &&
+      supportsRetryableWrites &&
+      notInTransaction &&
+      notExplaining;
+
     const handler = (err, result) => {
       if (!err) return callback(null, result);
       if (!shouldRetryOperation(err)) {

package/lib/core/topologies/mongos.js

@@ -88,6 +88,7 @@ var handlers = ['connect', 'close', 'error', 'timeout', 'parseError'];
  * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
  * @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 {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.
  * @param {boolean} [options.monitorCommands=false] Enable command monitoring for this topology
  * @return {Mongos} A cursor instance

package/lib/core/topologies/replset.js

@@ -88,6 +88,7 @@ var handlers = ['connect', 'close', 'error', 'timeout', 'parseError'];
  * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
  * @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 {number} [options.pingInterval=5000] Ping interval to check the response time to the different servers
  * @param {number} [options.localThresholdMS=15] Cutoff latency point in MS for Replicaset member selection
  * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.

package/lib/core/topologies/server.js

@@ -16,6 +16,7 @@ var inherits = require('util').inherits,
   createCompressionInfo = require('./shared').createCompressionInfo,
   resolveClusterTime = require('./shared').resolveClusterTime,
   SessionMixins = require('./shared').SessionMixins,
+  extractCommand = require('../../command_utils').extractCommand,
   relayEvents = require('../utils').relayEvents;
 
 const collationNotSupported = require('../utils').collationNotSupported;
@@ -46,6 +47,7 @@ var debugFields = [
   'promoteLongs',
   'promoteValues',
   'promoteBuffers',
+  'bsonRegExp',
   'servername'
 ];
 
@@ -88,6 +90,7 @@ function topologyId(server) {
  * @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
  * @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 {string} [options.appname=null] Application name, passed in on ismaster call and logged in mongod server logs. Maximum size 128 bytes.
  * @param {boolean} [options.domainsEnabled=false] Enable the wrapping of the callback in the current domain, disabled by default to avoid perf hit.
  * @param {boolean} [options.monitorCommands=false] Enable command monitoring for this topology
@@ -608,18 +611,20 @@ Server.prototype.command = function(ns, cmd, options, callback) {
   options = Object.assign({}, options, { wireProtocolCommand: false });
 
   // Debug log
-  if (self.s.logger.isDebug())
+  if (self.s.logger.isDebug()) {
+    const extractedCommand = extractCommand(cmd);
     self.s.logger.debug(
       f(
         'executing command [%s] against %s',
         JSON.stringify({
           ns: ns,
-          cmd: cmd,
+          cmd: extractedCommand.shouldRedact ? `${extractedCommand.name} details REDACTED` : cmd,
           options: debugOptions(debugFields, options)
         }),
         self.name
       )
     );
+  }
 
   // If we are not connected or have a disconnectHandler specified
   if (disconnectHandler(self, 'command', ns, cmd, options, callback)) return;

package/lib/core/uri_parser.js

@@ -52,7 +52,9 @@ function parseSrvConnectionString(uri, options, callback) {
   }
 
   result.domainLength = result.hostname.split('.').length;
-  if (result.pathname && result.pathname.match(',')) {
+
+  const hostname = uri.substring('mongodb+srv://'.length).split('/')[0];
+  if (hostname.match(',')) {
     return callback(new MongoParseError('Invalid URI, cannot contain multiple hostnames'));
   }
 

package/lib/core/utils.js

@@ -27,6 +27,7 @@ function retrieveKerberos() {
   let kerberos;
 
   try {
+    // Ensure you always wrap an optional require in the try block NODE-3199
     kerberos = requireOptional('kerberos');
   } catch (err) {
     if (err.code === 'MODULE_NOT_FOUND') {

package/lib/core/wireprotocol/constants.js

@@ -1,9 +1,9 @@
 'use strict';
 
 const MIN_SUPPORTED_SERVER_VERSION = '2.6';
-const MAX_SUPPORTED_SERVER_VERSION = '4.4';
+const MAX_SUPPORTED_SERVER_VERSION = '5.0';
 const MIN_SUPPORTED_WIRE_VERSION = 2;
-const MAX_SUPPORTED_WIRE_VERSION = 9;
+const MAX_SUPPORTED_WIRE_VERSION = 13;
 
 module.exports = {
   MIN_SUPPORTED_SERVER_VERSION,

package/lib/core/wireprotocol/shared.js

@@ -57,6 +57,7 @@ function applyCommonQueryOptions(queryOptions, options) {
     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,
     monitoring: typeof options.monitoring === 'boolean' ? options.monitoring : false,
     fullResult: typeof options.fullResult === 'boolean' ? options.fullResult : false
   });

package/lib/cursor.js

@@ -742,7 +742,12 @@ class Cursor extends CoreCursor {
           return false;
         }
         if (doc != null) {
-          iterator(doc);
+          try {
+            iterator(doc);
+          } catch (error) {
+            callback(error);
+            return false;
+          }
           return true;
         }
         if (doc == null && callback) {
@@ -762,7 +767,12 @@ class Cursor extends CoreCursor {
             fulfill(null);
             return false;
           } else {
-            iterator(doc);
+            try {
+              iterator(doc);
+            } catch (error) {
+              reject(error);
+              return false;
+            }
             return true;
           }
         });

package/lib/db.js

@@ -83,7 +83,6 @@ const legalOptionNames = [
   'bufferMaxEntries',
   'authSource',
   'ignoreUndefined',
-  'promoteLongs',
   'promiseLibrary',
   'readConcern',
   'retryMiliSeconds',
@@ -95,6 +94,7 @@ const legalOptionNames = [
   'promoteBuffers',
   'promoteLongs',
   'promoteValues',
+  'bsonRegExp',
   'compression',
   'retryWrites'
 ];
@@ -117,6 +117,7 @@ const legalOptionNames = [
  * @param {boolean} [options.promoteLongs=true] Promotes Long values to number if they fit inside the 53 bits resolution.
  * @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
  * @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
+ * @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 {number} [options.bufferMaxEntries=-1] Sets a cap on how many operations the driver will buffer up before giving up on getting a working connection, default is -1 which is unlimited.
  * @param {(ReadPreference|string)} [options.readPreference] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  * @param {object} [options.pkFactory] A primary key factory object for generation of custom _id keys.
@@ -323,6 +324,7 @@ Db.prototype.command = function(command, 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 {object} [options.collation] Specify collation (MongoDB 3.4 or higher) settings for update operation (see 3.4 documentation for available fields).
  * @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
@@ -391,7 +393,8 @@ const COLLECTION_OPTION_KEYS = [
   'ignoreUndefined',
   'promoteValues',
   'promoteBuffers',
-  'promoteLongs'
+  'promoteLongs',
+  'bsonRegExp'
 ];
 
 /**
@@ -409,91 +412,98 @@ const COLLECTION_OPTION_KEYS = [
  * @param {object} [options.pkFactory] A primary key factory object for generation of custom _id keys.
  * @param {(ReadPreference|string)} [options.readPreference] The preferred read preference (ReadPreference.PRIMARY, ReadPreference.PRIMARY_PREFERRED, ReadPreference.SECONDARY, ReadPreference.SECONDARY_PREFERRED, ReadPreference.NEAREST).
  * @param {boolean} [options.serializeFunctions=false] Serialize functions on any object.
- * @param {boolean} [options.strict=false] Returns an error if the collection does not exist
+ * @param {boolean} [options.strict=false] **Deprecated** Returns an error if the collection does not exist
  * @param {object} [options.readConcern] Specify a read concern for the collection. (only MongoDB 3.2 or higher supported)
  * @param {ReadConcernLevel} [options.readConcern.level='local'] Specify a read concern level for the collection operations (only MongoDB 3.2 or higher supported)
  * @param {Db~collectionResultCallback} [callback] The collection result callback
  * @return {Collection} return the new Collection instance if not in strict mode
  */
-Db.prototype.collection = function(name, options, callback) {
-  if (typeof options === 'function') (callback = options), (options = {});
-  options = options || {};
-  options = Object.assign({}, options);
-
-  // Set the promise library
-  options.promiseLibrary = this.s.promiseLibrary;
+Db.prototype.collection = deprecateOptions(
+  {
+    name: 'Db.collection',
+    deprecatedOptions: ['strict'],
+    optionsIndex: 1
+  },
+  function(name, options, callback) {
+    if (typeof options === 'function') (callback = options), (options = {});
+    options = options || {};
+    options = Object.assign({}, options);
 
-  // If we have not set a collection level readConcern set the db level one
-  options.readConcern = options.readConcern
-    ? new ReadConcern(options.readConcern.level)
-    : this.readConcern;
+    // Set the promise library
+    options.promiseLibrary = this.s.promiseLibrary;
 
-  // Do we have ignoreUndefined set
-  if (this.s.options.ignoreUndefined) {
-    options.ignoreUndefined = this.s.options.ignoreUndefined;
-  }
+    // If we have not set a collection level readConcern set the db level one
+    options.readConcern = options.readConcern
+      ? new ReadConcern(options.readConcern.level)
+      : this.readConcern;
 
-  for (const collectionOptionKey of COLLECTION_OPTION_KEYS) {
-    if (!(collectionOptionKey in options) && this.s.options[collectionOptionKey] !== undefined) {
-      options[collectionOptionKey] = this.s.options[collectionOptionKey];
+    // Do we have ignoreUndefined set
+    if (this.s.options.ignoreUndefined) {
+      options.ignoreUndefined = this.s.options.ignoreUndefined;
     }
-  }
 
-  // Merge in all needed options and ensure correct writeConcern merging from db level
-  options = conditionallyMergeWriteConcern(options, this.s.options);
-
-  // Execute
-  if (options == null || !options.strict) {
-    try {
-      const collection = new Collection(
-        this,
-        this.s.topology,
-        this.databaseName,
-        name,
-        this.s.pkFactory,
-        options
-      );
-      if (callback) callback(null, collection);
-      return collection;
-    } catch (err) {
-      if (err instanceof MongoError && callback) return callback(err);
-      throw err;
+    for (const collectionOptionKey of COLLECTION_OPTION_KEYS) {
+      if (!(collectionOptionKey in options) && this.s.options[collectionOptionKey] !== undefined) {
+        options[collectionOptionKey] = this.s.options[collectionOptionKey];
+      }
     }
-  }
 
-  // Strict mode
-  if (typeof callback !== 'function') {
-    throw toError(`A callback is required in strict mode. While getting collection ${name}`);
-  }
+    // Merge in all needed options and ensure correct writeConcern merging from db level
+    options = conditionallyMergeWriteConcern(options, this.s.options);
+
+    // Execute
+    if (options == null || !options.strict) {
+      try {
+        const collection = new Collection(
+          this,
+          this.s.topology,
+          this.databaseName,
+          name,
+          this.s.pkFactory,
+          options
+        );
+        if (callback) callback(null, collection);
+        return collection;
+      } catch (err) {
+        if (err instanceof MongoError && callback) return callback(err);
+        throw err;
+      }
+    }
 
-  // Did the user destroy the topology
-  if (this.serverConfig && this.serverConfig.isDestroyed()) {
-    return callback(new MongoError('topology was destroyed'));
-  }
+    // Strict mode
+    if (typeof callback !== 'function') {
+      throw toError(`A callback is required in strict mode. While getting collection ${name}`);
+    }
 
-  const listCollectionOptions = Object.assign({}, options, { nameOnly: true });
-
-  // Strict mode
-  this.listCollections({ name: name }, listCollectionOptions).toArray((err, collections) => {
-    if (err != null) return handleCallback(callback, err, null);
-    if (collections.length === 0)
-      return handleCallback(
-        callback,
-        toError(`Collection ${name} does not exist. Currently in strict mode.`),
-        null
-      );
-
-    try {
-      return handleCallback(
-        callback,
-        null,
-        new Collection(this, this.s.topology, this.databaseName, name, this.s.pkFactory, options)
-      );
-    } catch (err) {
-      return handleCallback(callback, err, null);
+    // Did the user destroy the topology
+    if (this.serverConfig && this.serverConfig.isDestroyed()) {
+      return callback(new MongoError('topology was destroyed'));
     }
-  });
-};
+
+    const listCollectionOptions = Object.assign({}, options, { nameOnly: true });
+
+    // Strict mode
+    this.listCollections({ name: name }, listCollectionOptions).toArray((err, collections) => {
+      if (err != null) return handleCallback(callback, err, null);
+      if (collections.length === 0)
+        return handleCallback(
+          callback,
+          toError(`Collection ${name} does not exist. Currently in strict mode.`),
+          null
+        );
+
+      try {
+        return handleCallback(
+          callback,
+          null,
+          new Collection(this, this.s.topology, this.databaseName, name, this.s.pkFactory, options)
+        );
+      } catch (err) {
+        return handleCallback(callback, err, null);
+      }
+    });
+  }
+);
 
 /**
  * Create a new collection on a server with the specified options. Use this to create capped collections.
@@ -941,6 +951,7 @@ Db.prototype.indexInformation = function(name, options, callback) {
 /**
  * Unref all sockets
  * @method
+ * @deprecated This function is deprecated and will be removed in the next major version.
  */
 Db.prototype.unref = function() {
   this.s.topology.unref();