mongodb 3.7.0 → 3.7.1

package/lib/cmap/connection_pool.js

@@ -158,12 +158,13 @@ class ConnectionPool extends EventEmitter {
       waitQueueTimeoutMS:
         typeof options.waitQueueTimeoutMS === 'number' ? options.waitQueueTimeoutMS : 0,
       autoEncrypter: options.autoEncrypter,
-      metadata: options.metadata
+      metadata: options.metadata,
+      useUnifiedTopology: options.useUnifiedTopology
     });
 
     if (options.minSize > options.maxSize) {
       throw new TypeError(
-        'Connection pool minimum size must not be greater than maxiumum pool size'
+        'Connection pool minimum size must not be greater than maximum pool size'
       );
     }
 

package/lib/core/connection/connect.js

@@ -95,6 +95,8 @@ function performInitialHandshake(conn, options, _callback) {
       handshakeOptions.socketTimeout = options.connectTimeoutMS || options.connectionTimeout;
     }
 
+    handshakeDoc.helloOk = !!options.useUnifiedTopology;
+
     const start = new Date().getTime();
     conn.command('admin.$cmd', handshakeDoc, handshakeOptions, (err, result) => {
       if (err) {
@@ -113,6 +115,10 @@ function performInitialHandshake(conn, options, _callback) {
         response.ismaster = response.isWritablePrimary;
       }
 
+      if (options.useUnifiedTopology && response.helloOk) {
+        conn.helloOk = true;
+      }
+
       const supportedServerErr = checkSupportedServer(response, options);
       if (supportedServerErr) {
         callback(supportedServerErr);
@@ -272,12 +278,17 @@ function makeConnection(family, options, cancellationToken, _callback) {
       : typeof options.connectTimeoutMS === 'number'
       ? options.connectTimeoutMS
       : 30000;
-  const socketTimeout = typeof options.socketTimeout === 'number' ? options.socketTimeout : 0;
+  const socketTimeoutMS =
+    typeof options.socketTimeoutMS === 'number'
+      ? options.socketTimeoutMS
+      : typeof options.socketTimeout === 'number'
+      ? options.socketTimeout
+      : 0;
   const rejectUnauthorized =
     typeof options.rejectUnauthorized === 'boolean' ? options.rejectUnauthorized : true;
 
-  if (keepAliveInitialDelay > socketTimeout) {
-    keepAliveInitialDelay = Math.round(socketTimeout / 2);
+  if (keepAliveInitialDelay > socketTimeoutMS) {
+    keepAliveInitialDelay = Math.round(socketTimeoutMS / 2);
   }
 
   let socket;
@@ -330,7 +341,7 @@ function makeConnection(family, options, cancellationToken, _callback) {
       return callback(socket.authorizationError);
     }
 
-    socket.setTimeout(socketTimeout);
+    socket.setTimeout(socketTimeoutMS);
     callback(null, socket);
   }
 

package/lib/core/connection/connection.js

@@ -91,6 +91,7 @@ class Connection extends EventEmitter {
     this.bson = options.bson;
     this.tag = options.tag;
     this.maxBsonMessageSize = options.maxBsonMessageSize || DEFAULT_MAX_BSON_MESSAGE_SIZE;
+    this.helloOk = undefined;
 
     this.port = options.port || 27017;
     this.host = options.host || 'localhost';

package/lib/core/error.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
+
 const kErrorLabels = Symbol('errorLabels');
 
 /**
@@ -216,32 +218,32 @@ class MongoWriteConcernError extends MongoError {
 
 // see: https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.rst#terms
 const RETRYABLE_ERROR_CODES = new Set([
-  6, // HostUnreachable
-  7, // HostNotFound
-  89, // NetworkTimeout
-  91, // ShutdownInProgress
-  189, // PrimarySteppedDown
-  9001, // SocketException
-  10107, // NotMaster
-  11600, // InterruptedAtShutdown
-  11602, // InterruptedDueToReplStateChange
-  13435, // NotMasterNoSlaveOk
-  13436 // NotMasterOrSecondary
+  MONGODB_ERROR_CODES.HostUnreachable,
+  MONGODB_ERROR_CODES.HostNotFound,
+  MONGODB_ERROR_CODES.NetworkTimeout,
+  MONGODB_ERROR_CODES.ShutdownInProgress,
+  MONGODB_ERROR_CODES.PrimarySteppedDown,
+  MONGODB_ERROR_CODES.SocketException,
+  MONGODB_ERROR_CODES.NotMaster,
+  MONGODB_ERROR_CODES.InterruptedAtShutdown,
+  MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
+  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
+  MONGODB_ERROR_CODES.NotMasterOrSecondary
 ]);
 
 const RETRYABLE_WRITE_ERROR_CODES = new Set([
-  11600, // InterruptedAtShutdown
-  11602, // InterruptedDueToReplStateChange
-  10107, // NotMaster
-  13435, // NotMasterNoSlaveOk
-  13436, // NotMasterOrSecondary
-  189, // PrimarySteppedDown
-  91, // ShutdownInProgress
-  7, // HostNotFound
-  6, // HostUnreachable
-  89, // NetworkTimeout
-  9001, // SocketException
-  262 // ExceededTimeLimit
+  MONGODB_ERROR_CODES.InterruptedAtShutdown,
+  MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
+  MONGODB_ERROR_CODES.NotMaster,
+  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
+  MONGODB_ERROR_CODES.NotMasterOrSecondary,
+  MONGODB_ERROR_CODES.PrimarySteppedDown,
+  MONGODB_ERROR_CODES.ShutdownInProgress,
+  MONGODB_ERROR_CODES.HostNotFound,
+  MONGODB_ERROR_CODES.HostUnreachable,
+  MONGODB_ERROR_CODES.NetworkTimeout,
+  MONGODB_ERROR_CODES.SocketException,
+  MONGODB_ERROR_CODES.ExceededTimeLimit
 ]);
 
 function isRetryableWriteError(error) {
@@ -271,41 +273,44 @@ function isRetryableError(error) {
 }
 
 const SDAM_RECOVERING_CODES = new Set([
-  91, // ShutdownInProgress
-  189, // PrimarySteppedDown
-  11600, // InterruptedAtShutdown
-  11602, // InterruptedDueToReplStateChange
-  13436 // NotMasterOrSecondary
+  MONGODB_ERROR_CODES.ShutdownInProgress,
+  MONGODB_ERROR_CODES.PrimarySteppedDown,
+  MONGODB_ERROR_CODES.InterruptedAtShutdown,
+  MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
+  MONGODB_ERROR_CODES.NotMasterOrSecondary
 ]);
 
 const SDAM_NOTMASTER_CODES = new Set([
-  10107, // NotMaster
-  13435 // NotMasterNoSlaveOk
+  MONGODB_ERROR_CODES.NotMaster,
+  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
+  MONGODB_ERROR_CODES.LegacyNotPrimary
 ]);
 
 const SDAM_NODE_SHUTTING_DOWN_ERROR_CODES = new Set([
-  11600, // InterruptedAtShutdown
-  91 // ShutdownInProgress
+  MONGODB_ERROR_CODES.InterruptedAtShutdown,
+  MONGODB_ERROR_CODES.ShutdownInProgress
 ]);
 
 function isRecoveringError(err) {
-  if (err.code && SDAM_RECOVERING_CODES.has(err.code)) {
-    return true;
+  if (typeof err.code === 'number') {
+    // If any error code exists, we ignore the error.message
+    return SDAM_RECOVERING_CODES.has(err.code);
   }
 
-  return err.message.match(/not master or secondary/) || err.message.match(/node is recovering/);
+  return /not master or secondary/.test(err.message) || /node is recovering/.test(err.message);
 }
 
 function isNotMasterError(err) {
-  if (err.code && SDAM_NOTMASTER_CODES.has(err.code)) {
-    return true;
+  if (typeof err.code === 'number') {
+    // If any error code exists, we ignore the error.message
+    return SDAM_NOTMASTER_CODES.has(err.code);
   }
 
   if (isRecoveringError(err)) {
     return false;
   }
 
-  return err.message.match(/not master/);
+  return /not master/.test(err.message);
 }
 
 function isNodeShuttingDownError(err) {
@@ -316,10 +321,9 @@ function isNodeShuttingDownError(err) {
  * Determines whether SDAM can recover from a given error. If it cannot
  * then the pool will be cleared, and server state will completely reset
  * locally.
- *
- * @ignore
  * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#not-master-and-node-is-recovering
- * @param {MongoError|Error} error
+ * @param {MongoError} error
+ * @returns {boolean}
  */
 function isSDAMUnrecoverableError(error) {
   // NOTE: null check is here for a strictly pre-CMAP world, a timeout or
@@ -328,11 +332,7 @@ function isSDAMUnrecoverableError(error) {
     return true;
   }
 
-  if (isRecoveringError(error) || isNotMasterError(error)) {
-    return true;
-  }
-
-  return false;
+  return isRecoveringError(error) || isNotMasterError(error);
 }
 
 module.exports = {

package/lib/core/sdam/monitor.js

@@ -65,7 +65,8 @@ class Monitor extends EventEmitter {
       heartbeatFrequencyMS:
         typeof options.heartbeatFrequencyMS === 'number' ? options.heartbeatFrequencyMS : 10000,
       minHeartbeatFrequencyMS:
-        typeof options.minHeartbeatFrequencyMS === 'number' ? options.minHeartbeatFrequencyMS : 500
+        typeof options.minHeartbeatFrequencyMS === 'number' ? options.minHeartbeatFrequencyMS : 500,
+      useUnifiedTopology: options.useUnifiedTopology
     });
 
     // TODO: refactor this to pull it directly from the pool, requires new ConnectionPool integration
@@ -205,8 +206,15 @@ function checkServer(monitor, callback) {
     const topologyVersion = monitor[kServer].description.topologyVersion;
     const isAwaitable = topologyVersion != null;
     const serverApi = monitor[kConnection].serverApi;
+    const helloOk = monitor[kConnection].helloOk;
+
+    const cmd = {
+      [serverApi || helloOk ? 'hello' : 'ismaster']: true
+    };
+
+    // written this way omit helloOk from the command if its false-y (do not want -> helloOk: null)
+    if (helloOk) cmd.helloOk = helloOk;
 
-    const cmd = { [serverApi ? 'hello' : 'ismaster']: true };
     const options = { socketTimeout: connectTimeoutMS };
 
     if (isAwaitable) {

package/lib/core/sdam/server_description.js

@@ -70,6 +70,10 @@ class ServerDescription {
       ismaster
     );
 
+    if (ismaster.isWritablePrimary != null) {
+      ismaster.ismaster = ismaster.isWritablePrimary;
+    }
+
     this.address = address;
     this.error = options.error;
     this.roundTripTime = options.roundTripTime || -1;

package/lib/core/topologies/replset_state.js

@@ -34,7 +34,7 @@ var ReplSetState = function(options) {
   // Add event listener
   EventEmitter.call(this);
   // Topology state
-  this.topologyType = TopologyType.ReplicaSetNoPrimary;
+  this.topologyType = options.setName ? TopologyType.ReplicaSetNoPrimary : TopologyType.Unknown;
   this.setName = options.setName;
 
   // Server set
@@ -218,7 +218,8 @@ const isArbiter = ismaster => ismaster.arbiterOnly && ismaster.setName;
 ReplSetState.prototype.update = function(server) {
   var self = this;
   // Get the current ismaster
-  var ismaster = server.lastIsMaster();
+  const ismaster = server.lastIsMaster();
+  if (ismaster && ismaster.isWritablePrimary) ismaster.ismaster = ismaster.isWritablePrimary;
 
   // Get the server name and lowerCase it
   var serverName = server.name.toLowerCase();
@@ -358,7 +359,8 @@ ReplSetState.prototype.update = function(server) {
   // Standalone server, destroy and return
   //
   if (ismaster && ismaster.ismaster && !ismaster.setName) {
-    this.topologyType = this.primary ? TopologyType.ReplicaSetWithPrimary : TopologyType.Unknown;
+    // We should not mark the topology as Unknown because of one standalone
+    // we should just remove this server from the set
     this.remove(server, { force: true });
     return false;
   }

package/lib/core/topologies/shared.js

@@ -1,11 +1,14 @@
 'use strict';
+
+const MONGODB_ERROR_CODES = require('../../error_codes').MONGODB_ERROR_CODES;
 const ReadPreference = require('./read_preference');
 const TopologyType = require('../sdam/common').TopologyType;
 const MongoError = require('../error').MongoError;
 const isRetryableWriteError = require('../error').isRetryableWriteError;
 const maxWireVersion = require('../utils').maxWireVersion;
 const MongoNetworkError = require('../error').MongoNetworkError;
-const MMAPv1_RETRY_WRITES_ERROR_CODE = 20;
+
+const MMAPv1_RETRY_WRITES_ERROR_CODE = MONGODB_ERROR_CODES.IllegalOperation;
 
 /**
  * Emit event if it exists

package/lib/core/uri_parser.js

@@ -106,6 +106,11 @@ function parseSrvConnectionString(uri, options, callback) {
         }
 
         record = qs.parse(record[0].join(''));
+
+        if (Object.keys(record).some(k => k.toLowerCase() === 'loadbalanced')) {
+          return callback(new MongoParseError('Load balancer mode requires driver version 4+'));
+        }
+
         if (Object.keys(record).some(key => key !== 'authSource' && key !== 'replicaSet')) {
           return callback(
             new MongoParseError('Text record must only set `authSource` or `replicaSet`')
@@ -598,6 +603,10 @@ function parseConnectionString(uri, options, callback) {
 
   parsedOptions = Object.assign({}, parsedOptions, options);
 
+  if (Object.keys(parsedOptions).some(k => k.toLowerCase() === 'loadbalanced')) {
+    return callback(new MongoParseError('Load balancer mode requires driver version 4+'));
+  }
+
   if (protocol === PROTOCOL_MONGODB_SRV) {
     return parseSrvConnectionString(uri, parsedOptions, callback);
   }

package/lib/error.js

@@ -1,27 +1,28 @@
 'use strict';
 
 const MongoNetworkError = require('./core').MongoNetworkError;
+const MONGODB_ERROR_CODES = require('./error_codes').MONGODB_ERROR_CODES;
 
 // From spec@https://github.com/mongodb/specifications/blob/f93d78191f3db2898a59013a7ed5650352ef6da8/source/change-streams/change-streams.rst#resumable-error
 const GET_MORE_RESUMABLE_CODES = new Set([
-  6, // HostUnreachable
-  7, // HostNotFound
-  89, // NetworkTimeout
-  91, // ShutdownInProgress
-  189, // PrimarySteppedDown
-  262, // ExceededTimeLimit
-  9001, // SocketException
-  10107, // NotMaster
-  11600, // InterruptedAtShutdown
-  11602, // InterruptedDueToReplStateChange
-  13435, // NotMasterNoSlaveOk
-  13436, // NotMasterOrSecondary
-  63, // StaleShardVersion
-  150, // StaleEpoch
-  13388, // StaleConfig
-  234, // RetryChangeStream
-  133, // FailedToSatisfyReadPreference
-  43 // CursorNotFound
+  MONGODB_ERROR_CODES.HostUnreachable,
+  MONGODB_ERROR_CODES.HostNotFound,
+  MONGODB_ERROR_CODES.NetworkTimeout,
+  MONGODB_ERROR_CODES.ShutdownInProgress,
+  MONGODB_ERROR_CODES.PrimarySteppedDown,
+  MONGODB_ERROR_CODES.ExceededTimeLimit,
+  MONGODB_ERROR_CODES.SocketException,
+  MONGODB_ERROR_CODES.NotMaster,
+  MONGODB_ERROR_CODES.InterruptedAtShutdown,
+  MONGODB_ERROR_CODES.InterruptedDueToReplStateChange,
+  MONGODB_ERROR_CODES.NotMasterNoSlaveOk,
+  MONGODB_ERROR_CODES.NotMasterOrSecondary,
+  MONGODB_ERROR_CODES.StaleShardVersion,
+  MONGODB_ERROR_CODES.StaleEpoch,
+  MONGODB_ERROR_CODES.StaleConfig,
+  MONGODB_ERROR_CODES.RetryChangeStream,
+  MONGODB_ERROR_CODES.FailedToSatisfyReadPreference,
+  MONGODB_ERROR_CODES.CursorNotFound
 ]);
 
 function isResumableError(error, wireVersion) {
@@ -31,7 +32,7 @@ function isResumableError(error, wireVersion) {
 
   if (wireVersion >= 9) {
     // DRIVERS-1308: For 4.4 drivers running against 4.4 servers, drivers will add a special case to treat the CursorNotFound error code as resumable
-    if (error.code === 43) {
+    if (error.code === MONGODB_ERROR_CODES.CursorNotFound) {
       return true;
     }
     return error.hasErrorLabel('ResumableChangeStreamError');
@@ -40,4 +41,4 @@ function isResumableError(error, wireVersion) {
   return GET_MORE_RESUMABLE_CODES.has(error.code);
 }
 
-module.exports = { GET_MORE_RESUMABLE_CODES, isResumableError };
+module.exports = { GET_MORE_RESUMABLE_CODES, isResumableError, MONGODB_ERROR_CODES };

package/lib/error_codes.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const MONGODB_ERROR_CODES = Object.freeze({
+  HostUnreachable: 6,
+  HostNotFound: 7,
+  NetworkTimeout: 89,
+  ShutdownInProgress: 91,
+  PrimarySteppedDown: 189,
+  ExceededTimeLimit: 262,
+  SocketException: 9001,
+  NotMaster: 10107,
+  InterruptedAtShutdown: 11600,
+  InterruptedDueToReplStateChange: 11602,
+  NotMasterNoSlaveOk: 13435,
+  NotMasterOrSecondary: 13436,
+  StaleShardVersion: 63,
+  StaleEpoch: 150,
+  StaleConfig: 13388,
+  RetryChangeStream: 234,
+  FailedToSatisfyReadPreference: 133,
+  CursorNotFound: 43,
+  LegacyNotPrimary: 10058,
+  WriteConcernFailed: 64,
+  NamespaceNotFound: 26,
+  IllegalOperation: 20,
+  MaxTimeMSExpired: 50,
+  UnknownReplWriteConcern: 79,
+  UnsatisfiableWriteConcern: 100,
+  DuplicateKey: 11000,
+  CannotCreateIndex: 67,
+  IndexOptionsConflict: 85,
+  IndexKeySpecsConflict: 86,
+  InvalidIndexSpecificationOption: 197
+});
+
+module.exports = Object.freeze({ MONGODB_ERROR_CODES });

package/lib/gridfs-stream/upload.js

@@ -1,14 +1,13 @@
 'use strict';
 
-var core = require('../core');
-var crypto = require('crypto');
-var stream = require('stream');
-var util = require('util');
-var Buffer = require('safe-buffer').Buffer;
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
+const core = require('../core');
+const crypto = require('crypto');
+const stream = require('stream');
+const util = require('util');
+const Buffer = require('safe-buffer').Buffer;
 const deprecateOptions = require('../utils').deprecateOptions;
 
-const ERROR_NAMESPACE_NOT_FOUND = 26;
-
 /**
  * A writable stream that enables you to write buffers to GridFS.
  *
@@ -216,7 +215,7 @@ function checkChunksIndex(_this, callback) {
   _this.chunks.listIndexes().toArray(function(error, indexes) {
     if (error) {
       // Collection doesn't exist so create index
-      if (error.code === ERROR_NAMESPACE_NOT_FOUND) {
+      if (error.code === MONGODB_ERROR_CODES.NamespaceNotFound) {
         var index = { files_id: 1, n: 1 };
         _this.chunks.createIndex(index, { background: false, unique: true }, function(error) {
           if (error) {
@@ -315,7 +314,7 @@ function checkIndexes(_this, callback) {
     _this.files.listIndexes().toArray(function(error, indexes) {
       if (error) {
         // Collection doesn't exist so create index
-        if (error.code === ERROR_NAMESPACE_NOT_FOUND) {
+        if (error.code === MONGODB_ERROR_CODES.NamespaceNotFound) {
           var index = { filename: 1, uploadDate: 1 };
           _this.files.createIndex(index, { background: false }, function(error) {
             if (error) {

package/lib/operations/db_ops.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
 const applyWriteConcern = require('../utils').applyWriteConcern;
 const Code = require('../core').BSON.Code;
 const debugOptions = require('../utils').debugOptions;
@@ -75,12 +76,12 @@ function createIndex(db, name, fieldOrSpec, options, callback) {
      * 197 = 'InvalidIndexSpecificationOption' (`_id` with `background: true`)
      */
     if (
-      err.code === 67 ||
-      err.code === 11000 ||
-      err.code === 85 ||
-      err.code === 86 ||
-      err.code === 11600 ||
-      err.code === 197
+      err.code === MONGODB_ERROR_CODES.CannotCreateIndex ||
+      err.code === MONGODB_ERROR_CODES.DuplicateKey ||
+      err.code === MONGODB_ERROR_CODES.IndexOptionsConflict ||
+      err.code === MONGODB_ERROR_CODES.IndexKeySpecsConflict ||
+      err.code === MONGODB_ERROR_CODES.InterruptedAtShutdown ||
+      err.code === MONGODB_ERROR_CODES.InvalidIndexSpecificationOption
     ) {
       return handleCallback(callback, err, result);
     }
@@ -147,7 +148,9 @@ function ensureIndex(db, name, fieldOrSpec, options, callback) {
 
   // Check if the index already exists
   indexInformation(db, name, finalOptions, (err, indexInformation) => {
-    if (err != null && err.code !== 26) return handleCallback(callback, err, null);
+    if (err != null && err.code !== MONGODB_ERROR_CODES.NamespaceNotFound) {
+      return handleCallback(callback, err, null);
+    }
     // If the index does not exist, create it
     if (indexInformation == null || !indexInformation[index_name]) {
       createIndex(db, name, fieldOrSpec, options, callback);

package/lib/operations/estimated_document_count.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const MONGODB_ERROR_CODES = require('../error_codes').MONGODB_ERROR_CODES;
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
 const CommandOperationV2 = require('./command_v2');
@@ -30,7 +31,7 @@ class EstimatedDocumentCountOperation extends CommandOperationV2 {
     }
 
     super.executeCommand(server, cmd, (err, response) => {
-      if (err && err.code !== 26) {
+      if (err && err.code !== MONGODB_ERROR_CODES.NamespaceNotFound) {
         callback(err);
         return;
       }

package/lib/topologies/native_topology.js

@@ -46,6 +46,8 @@ class NativeTopology extends Topology {
 
     clonedOptions.serverApi = options.serverApi;
 
+    clonedOptions.useUnifiedTopology = options.useUnifiedTopology;
+
     super(servers, clonedOptions);
   }
 

package/lib/url_parser.js

@@ -101,6 +101,9 @@ module.exports = function(url, options, callback) {
         record = record[0].join('');
         const parsedRecord = qs.parse(record);
         const items = Object.keys(parsedRecord);
+        if (Object.keys(items).some(k => k.toLowerCase() === 'loadbalanced')) {
+          return callback(new MongoParseError('Load balancer mode requires driver version 4+'));
+        }
         if (items.some(item => item !== 'authSource' && item !== 'replicaSet')) {
           return callback(
             new MongoParseError('Text record must only set `authSource` or `replicaSet`')
@@ -378,6 +381,11 @@ function parseConnectionString(url, options) {
   object.dbName = dbName || 'admin';
   // Split up all the options
   urlOptions = (query_string_part || '').split(/[&;]/);
+
+  if (urlOptions.some(k => k.toLowerCase() === 'loadbalanced')) {
+    throw new MongoParseError('Load balancer mode requires driver version 4+');
+  }
+
   // Ugh, we have to figure out which options go to which constructor manually.
   urlOptions.forEach(function(opt) {
     if (!opt) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.7.0",
+  "version": "3.7.1",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [