mongodb 3.6.4 → 3.6.5

package/HISTORY.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [3.6.5](https://github.com/mongodb/node-mongodb-native/compare/v3.6.4...v3.6.5) (2021-03-16)
+
+
+### Bug Fixes
+
+* MongoError circular dependency warning ([#2734](https://github.com/mongodb/node-mongodb-native/issues/2734)) ([d67ffa7](https://github.com/mongodb/node-mongodb-native/commit/d67ffa7a2e3f86734c7e9b6944aab1d765b9e75e))
+* move session support check to operation layer ([#2739](https://github.com/mongodb/node-mongodb-native/issues/2739)) ([8b370a7](https://github.com/mongodb/node-mongodb-native/commit/8b370a7ad784f5759c964cdfaec62e06c896dc95))
+* session support detection spec compliance ([#2732](https://github.com/mongodb/node-mongodb-native/issues/2732)) ([9baec71](https://github.com/mongodb/node-mongodb-native/commit/9baec7128f612f2d9c290c85d24e33602f911499))
+* use emitWarning API for internal messages ([#2743](https://github.com/mongodb/node-mongodb-native/issues/2743)) ([8bd9777](https://github.com/mongodb/node-mongodb-native/commit/8bd9777b0aedd56b81675c3e79fae63432319982))
+
 ### [3.6.4](https://github.com/mongodb/node-mongodb-native/compare/v3.6.3...v3.6.4) (2021-02-02)
 
 

package/README.md

@@ -1,21 +1,24 @@
-[![npm](https://nodei.co/npm/mongodb.png?downloads=true&downloadRank=true)](https://nodei.co/npm/mongodb/) [![npm](https://nodei.co/npm-dl/mongodb.png?months=6&height=3)](https://nodei.co/npm/mongodb/)
+# MongoDB NodeJS Driver
 
-[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/mongodb/node-mongodb-native?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+[![npm](https://nodei.co/npm/mongodb.png?downloads=true&downloadRank=true)](https://nodei.co/npm/mongodb/)
 
-# Description
+The official [MongoDB](https://www.mongodb.com/) driver for Node.js.
 
-The official [MongoDB](https://www.mongodb.com/) driver for Node.js. Provides a high-level API on top of [mongodb-core](https://www.npmjs.com/package/mongodb-core) that is meant for end users.
+**NOTE: v3.x released with breaking API changes. You can find a list of changes [here](CHANGES_3.0.0.md).**
 
-**NOTE: v3.x was recently released with breaking API changes. You can find a list of changes [here](CHANGES_3.0.0.md).**
+## Version 4.0
 
-## MongoDB Node.JS Driver
+**Looking for the latest?** We're working on the next major version of the driver, now in beta.
+Check out our [beta version 4.0 here](https://github.com/mongodb/node-mongodb-native/tree/4.0), which includes a full migration of the driver to TypeScript.
 
-| what          | where                                          |
-|---------------|------------------------------------------------|
-| documentation | http://mongodb.github.io/node-mongodb-native  |
-| api-doc        | http://mongodb.github.io/node-mongodb-native/3.6/api  |
-| source        | https://github.com/mongodb/node-mongodb-native |
-| mongodb       | http://www.mongodb.org                        |
+## Quick Links
+
+| what          | where                                                |
+| ------------- | ---------------------------------------------------- |
+| documentation | http://mongodb.github.io/node-mongodb-native         |
+| api-doc       | http://mongodb.github.io/node-mongodb-native/3.6/api |
+| source        | https://github.com/mongodb/node-mongodb-native       |
+| mongodb       | http://www.mongodb.org                               |
 
 ### Bugs / Feature Requests
 
@@ -41,12 +44,12 @@ Change history can be found in [`HISTORY.md`](HISTORY.md).
 
 For version compatibility matrices, please refer to the following links:
 
- * [MongoDB](https://docs.mongodb.com/ecosystem/drivers/driver-compatibility-reference/#reference-compatibility-mongodb-node)
- * [NodeJS](https://docs.mongodb.com/ecosystem/drivers/driver-compatibility-reference/#reference-compatibility-language-node)
+- [MongoDB](https://docs.mongodb.com/ecosystem/drivers/driver-compatibility-reference/#reference-compatibility-mongodb-node)
+- [NodeJS](https://docs.mongodb.com/ecosystem/drivers/driver-compatibility-reference/#reference-compatibility-language-node)
 
-# Installation
+## Installation
 
-The recommended way to get started using the Node.js 3.0 driver is by using the `npm` (Node Package Manager) to install the dependency in your project.
+The recommended way to get started using the Node.js driver is by using `npm` (Node Package Manager) to install the dependency in your project.
 
 ## MongoDB Driver
 
@@ -64,10 +67,10 @@ You can also use the [Yarn](https://yarnpkg.com/en) package manager.
 
 The MongoDB driver depends on several other packages. These are:
 
-* [mongodb-core](https://github.com/mongodb-js/mongodb-core)
-* [bson](https://github.com/mongodb/js-bson)
-* [kerberos](https://github.com/mongodb-js/kerberos)
-* [node-gyp](https://github.com/nodejs/node-gyp)
+- [bson](https://github.com/mongodb/js-bson)
+- [bson-ext](https://github.com/mongodb-js/bson-ext)
+- [kerberos](https://github.com/mongodb-js/kerberos)
+- [mongodb-client-encryption](https://github.com/mongodb/libmongocrypt#readme)
 
 The `kerberos` package is a C++ extension that requires a build environment to be installed on your system. You must be able to build Node.js itself in order to compile and install the `kerberos` module. Furthermore, the `kerberos` module requires the MIT Kerberos package to correctly compile on UNIX operating systems. Consult your UNIX operation system package manager for what libraries to install.
 
@@ -108,9 +111,9 @@ This will print out all the steps npm is performing while trying to install the
 
 A compiler tool chain known to work for compiling `kerberos` on Windows is the following.
 
-* Visual Studio C++ 2010 (do not use higher versions)
-* Windows 7 64bit SDK
-* Python 2.7 or higher
+- Visual Studio C++ 2010 (do not use higher versions)
+- Windows 7 64bit SDK
+- Python 2.7 or higher
 
 Open the Visual Studio command prompt. Ensure `node.exe` is in your path and install `node-gyp`.
 
@@ -168,7 +171,7 @@ For complete MongoDB installation instructions, see [the manual](https://docs.mo
 
 1. Download the right MongoDB version from [MongoDB](https://www.mongodb.org/downloads)
 2. Create a database directory (in this case under **/data**).
-3. Install and start a ``mongod`` process.
+3. Install and start a `mongod` process.
 
 ```bash
 mongod --dbpath=/data
@@ -192,11 +195,11 @@ const url = 'mongodb://localhost:27017';
 
 // Database Name
 const dbName = 'myproject';
-
+const client = new MongoClient(url);
 // Use connect method to connect to the server
-MongoClient.connect(url, function(err, client) {
+client.connect(function(err) {
   assert.equal(null, err);
-  console.log("Connected successfully to server");
+  console.log('Connected successfully to server');
 
   const db = client.db(dbName);
 
@@ -222,23 +225,21 @@ const insertDocuments = function(db, callback) {
   // Get the documents collection
   const collection = db.collection('documents');
   // Insert some documents
-  collection.insertMany([
-    {a : 1}, {a : 2}, {a : 3}
-  ], function(err, result) {
+  collection.insertMany([{ a: 1 }, { a: 2 }, { a: 3 }], function(err, result) {
     assert.equal(err, null);
     assert.equal(3, result.result.n);
     assert.equal(3, result.ops.length);
-    console.log("Inserted 3 documents into the collection");
+    console.log('Inserted 3 documents into the collection');
     callback(result);
   });
-}
+};
 ```
 
 The **insert** command returns an object with the following fields:
 
-* **result** Contains the result document from MongoDB
-* **ops** Contains the documents inserted with added **_id** fields
-* **connection** Contains the connection used to perform the insert
+- **result** Contains the result document from MongoDB
+- **ops** Contains the documents inserted with added **\_id** fields
+- **connection** Contains the connection used to perform the insert
 
 Add the following code to call the **insertDocuments** function:
 
@@ -255,7 +256,7 @@ const dbName = 'myproject';
 // Use connect method to connect to the server
 MongoClient.connect(url, function(err, client) {
   assert.equal(null, err);
-  console.log("Connected successfully to server");
+  console.log('Connected successfully to server');
 
   const db = client.db(dbName);
 
@@ -289,11 +290,11 @@ const findDocuments = function(db, callback) {
   // Find some documents
   collection.find({}).toArray(function(err, docs) {
     assert.equal(err, null);
-    console.log("Found the following records");
-    console.log(docs)
+    console.log('Found the following records');
+    console.log(docs);
     callback(docs);
   });
-}
+};
 ```
 
 This query returns all the documents in the **documents** collection. Add the **findDocument** method to the **MongoClient.connect** callback:
@@ -311,7 +312,7 @@ const dbName = 'myproject';
 // Use connect method to connect to the server
 MongoClient.connect(url, function(err, client) {
   assert.equal(null, err);
-  console.log("Connected correctly to server");
+  console.log('Connected correctly to server');
 
   const db = client.db(dbName);
 
@@ -332,16 +333,16 @@ const findDocuments = function(db, callback) {
   // Get the documents collection
   const collection = db.collection('documents');
   // Find some documents
-  collection.find({'a': 3}).toArray(function(err, docs) {
+  collection.find({ a: 3 }).toArray(function(err, docs) {
     assert.equal(err, null);
-    console.log("Found the following records");
+    console.log('Found the following records');
     console.log(docs);
     callback(docs);
   });
-}
+};
 ```
 
-Only the documents which match ``'a' : 3`` should be returned.
+Only the documents which match `'a' : 3` should be returned.
 
 ### Update a document
 
@@ -352,14 +353,13 @@ const updateDocument = function(db, callback) {
   // Get the documents collection
   const collection = db.collection('documents');
   // Update document where a is 2, set b equal to 1
-  collection.updateOne({ a : 2 }
-    , { $set: { b : 1 } }, function(err, result) {
+  collection.updateOne({ a: 2 }, { $set: { b: 1 } }, function(err, result) {
     assert.equal(err, null);
     assert.equal(1, result.result.n);
-    console.log("Updated the document with the field a equal to 2");
+    console.log('Updated the document with the field a equal to 2');
     callback(result);
   });
-}
+};
 ```
 
 The method updates the first document where the field **a** is equal to **2** by adding a new field **b** to the document set to **1**. Next, update the callback function from **MongoClient.connect** to include the update method.
@@ -377,7 +377,7 @@ const dbName = 'myproject';
 // Use connect method to connect to the server
 MongoClient.connect(url, function(err, client) {
   assert.equal(null, err);
-  console.log("Connected successfully to server");
+  console.log('Connected successfully to server');
 
   const db = client.db(dbName);
 
@@ -398,13 +398,13 @@ const removeDocument = function(db, callback) {
   // Get the documents collection
   const collection = db.collection('documents');
   // Delete document where a is 3
-  collection.deleteOne({ a : 3 }, function(err, result) {
+  collection.deleteOne({ a: 3 }, function(err, result) {
     assert.equal(err, null);
     assert.equal(1, result.result.n);
-    console.log("Removed the document with the field a equal to 3");
+    console.log('Removed the document with the field a equal to 3');
     callback(result);
   });
-}
+};
 ```
 
 Add the new method to the **MongoClient.connect** callback function.
@@ -422,7 +422,7 @@ const dbName = 'myproject';
 // Use connect method to connect to the server
 MongoClient.connect(url, function(err, client) {
   assert.equal(null, err);
-  console.log("Connected successfully to server");
+  console.log('Connected successfully to server');
 
   const db = client.db(dbName);
 
@@ -444,18 +444,14 @@ performance. The following function creates an index on the **a** field in the
 
 ```js
 const indexCollection = function(db, callback) {
-  db.collection('documents').createIndex(
-    { "a": 1 },
-      null,
-      function(err, results) {
-        console.log(results);
-        callback();
-    }
-  );
+  db.collection('documents').createIndex({ a: 1 }, null, function(err, results) {
+    console.log(results);
+    callback();
+  });
 };
 ```
 
-Add the ``indexCollection`` method to your app:
+Add the `indexCollection` method to your app:
 
 ```js
 const MongoClient = require('mongodb').MongoClient;
@@ -469,7 +465,7 @@ const dbName = 'myproject';
 // Use connect method to connect to the server
 MongoClient.connect(url, function(err, client) {
   assert.equal(null, err);
-  console.log("Connected successfully to server");
+  console.log('Connected successfully to server');
 
   const db = client.db(dbName);
 
@@ -485,13 +481,13 @@ For more detailed information, see the [tutorials](docs/reference/content/tutori
 
 ## Next Steps
 
- * [MongoDB Documentation](http://mongodb.org)
- * [Read about Schemas](http://learnmongodbthehardway.com)
- * [Star us on GitHub](https://github.com/mongodb/node-mongodb-native)
+- [MongoDB Documentation](http://mongodb.org)
+- [Read about Schemas](http://learnmongodbthehardway.com)
+- [Star us on GitHub](https://github.com/mongodb/node-mongodb-native)
 
 ## License
 
 [Apache 2.0](LICENSE.md)
 
-© 2009-2012 Christian Amor Kvalheim  
+© 2009-2012 Christian Amor Kvalheim
 © 2012-present MongoDB [Contributors](CONTRIBUTORS.md)

package/lib/collection.js

@@ -2,6 +2,7 @@
 
 const deprecate = require('util').deprecate;
 const deprecateOptions = require('./utils').deprecateOptions;
+const emitWarningOnce = require('./utils').emitWarningOnce;
 const checkCollectionName = require('./utils').checkCollectionName;
 const ObjectID = require('./core').BSON.ObjectID;
 const MongoError = require('./core').MongoError;
@@ -323,7 +324,7 @@ Collection.prototype.find = deprecateOptions(
   function(query, options, callback) {
     if (typeof callback === 'object') {
       // TODO(MAJOR): throw in the future
-      console.warn('Third parameter to `find()` must be a callback or undefined');
+      emitWarningOnce('Third parameter to `find()` must be a callback or undefined');
     }
 
     let selector = query;
@@ -1092,7 +1093,7 @@ Collection.prototype.findOne = deprecateOptions(
   function(query, options, callback) {
     if (typeof callback === 'object') {
       // TODO(MAJOR): throw in the future
-      console.warn('Third parameter to `findOne()` must be a callback or undefined');
+      emitWarningOnce('Third parameter to `findOne()` must be a callback or undefined');
     }
 
     if (typeof query === 'function') (callback = query), (query = {}), (options = {});

package/lib/core/auth/scram.js

@@ -4,6 +4,7 @@ const Buffer = require('safe-buffer').Buffer;
 const retrieveBSON = require('../connection/utils').retrieveBSON;
 const MongoError = require('../error').MongoError;
 const AuthProvider = require('./auth_provider').AuthProvider;
+const emitWarningOnce = require('../../utils').emitWarning;
 
 const BSON = retrieveBSON();
 const Binary = BSON.Binary;
@@ -24,7 +25,7 @@ class ScramSHA extends AuthProvider {
   prepare(handshakeDoc, authContext, callback) {
     const cryptoMethod = this.cryptoMethod;
     if (cryptoMethod === 'sha256' && saslprep == null) {
-      console.warn('Warning: no saslprep library specified. Passwords will not be sanitized');
+      emitWarningOnce('Warning: no saslprep library specified. Passwords will not be sanitized');
     }
 
     crypto.randomBytes(24, (err, nonce) => {

package/lib/core/connection/logger.js

@@ -37,6 +37,7 @@ var Logger = function(className, options) {
   if (options.logger) {
     currentLogger = options.logger;
   } else if (currentLogger == null) {
+    // eslint-disable-next-line no-console
     currentLogger = console.log;
   }
 

package/lib/core/connection/msg.js

@@ -31,6 +31,7 @@ const Buffer = require('safe-buffer').Buffer;
 const opcodes = require('../wireprotocol/shared').opcodes;
 const databaseNamespace = require('../wireprotocol/shared').databaseNamespace;
 const ReadPreference = require('../topologies/read_preference');
+const MongoError = require('../../core/error').MongoError;
 
 // Incrementing request id
 let _requestId = 0;
@@ -196,7 +197,8 @@ class BinMsg {
     while (this.index < this.data.length) {
       const payloadType = this.data.readUInt8(this.index++);
       if (payloadType === 1) {
-        console.error('TYPE 1');
+        // It was decided that no driver makes use of payload type 1
+        throw new MongoError('OP_MSG Payload Type 1 detected unsupported protocol');
       } else if (payloadType === 0) {
         const bsonSize = this.data.readUInt32LE(this.index);
         const bin = this.data.slice(this.index, this.index + bsonSize);

package/lib/core/sdam/topology.js

@@ -27,6 +27,7 @@ const ServerSessionPool = require('../sessions').ServerSessionPool;
 const makeClientMetadata = require('../utils').makeClientMetadata;
 const CMAP_EVENT_NAMES = require('../../cmap/events').CMAP_EVENT_NAMES;
 const compareTopologyVersion = require('./server_description').compareTopologyVersion;
+const emitWarning = require('../../utils').emitWarning;
 
 const common = require('./common');
 const drainTimerQueue = common.drainTimerQueue;
@@ -739,7 +740,7 @@ class Topology extends EventEmitter {
   }
 
   unref() {
-    console.log('not implemented: `unref`');
+    emitWarning('not implemented: `unref`');
   }
 
   // NOTE: There are many places in code where we explicitly check the last isMaster

package/lib/core/sdam/topology_description.js

@@ -72,12 +72,30 @@ class TopologyDescription {
     // value among ServerDescriptions of all data-bearing server types. If any have a null
     // logicalSessionTimeoutMinutes, then TopologyDescription.logicalSessionTimeoutMinutes MUST be
     // set to null.
-    const readableServers = Array.from(this.servers.values()).filter(s => s.isReadable);
-    this.logicalSessionTimeoutMinutes = readableServers.reduce((result, server) => {
-      if (server.logicalSessionTimeoutMinutes == null) return null;
-      if (result == null) return server.logicalSessionTimeoutMinutes;
-      return Math.min(result, server.logicalSessionTimeoutMinutes);
-    }, null);
+    this.logicalSessionTimeoutMinutes = null;
+    for (const addressServerTuple of this.servers) {
+      const server = addressServerTuple[1];
+      if (server.isReadable) {
+        if (server.logicalSessionTimeoutMinutes == null) {
+          // If any of the servers have a null logicalSessionsTimeout, then the whole topology does
+          this.logicalSessionTimeoutMinutes = null;
+          break;
+        }
+
+        if (this.logicalSessionTimeoutMinutes == null) {
+          // First server with a non null logicalSessionsTimeout
+          this.logicalSessionTimeoutMinutes = server.logicalSessionTimeoutMinutes;
+          continue;
+        }
+
+        // Always select the smaller of the:
+        // current server logicalSessionsTimeout and the topologies logicalSessionsTimeout
+        this.logicalSessionTimeoutMinutes = Math.min(
+          this.logicalSessionTimeoutMinutes,
+          server.logicalSessionTimeoutMinutes
+        );
+      }
+    }
   }
 
   /**

package/lib/core/tools/smoke_plugin.js

@@ -52,6 +52,7 @@ exports.attachToRunner = function(runner, outputFile) {
     fs.writeFileSync(outputFile, JSON.stringify(smokeOutput));
 
     // Standard NodeJS uncaught exception handler
+    // eslint-disable-next-line no-console
     console.error(err.stack);
     process.exit(1);
   });

package/lib/core/topologies/read_preference.js

@@ -1,4 +1,5 @@
 'use strict';
+const emitWarningOnce = require('../../utils').emitWarningOnce;
 
 /**
  * The **ReadPreference** class is a class that represents a MongoDB ReadPreference and is
@@ -20,7 +21,7 @@ const ReadPreference = function(mode, tags, options) {
 
   // TODO(major): tags MUST be an array of tagsets
   if (tags && !Array.isArray(tags)) {
-    console.warn(
+    emitWarningOnce(
       'ReadPreference tags must be an array, this will change in the next major version'
     );
 

package/lib/core/uri_parser.js

@@ -4,6 +4,7 @@ const qs = require('querystring');
 const dns = require('dns');
 const MongoParseError = require('./error').MongoParseError;
 const ReadPreference = require('./topologies/read_preference');
+const emitWarningOnce = require('../utils').emitWarningOnce;
 
 /**
  * The following regular expression validates a connection string and breaks the
@@ -438,7 +439,7 @@ function parseQueryString(query, options) {
   // special cases for known deprecated options
   if (result.wtimeout && result.wtimeoutms) {
     delete result.wtimeout;
-    console.warn('Unsupported option `wtimeout` specified');
+    emitWarningOnce('Unsupported option `wtimeout` specified');
   }
 
   return Object.keys(result).length ? result : null;

package/lib/core/wireprotocol/kill_cursors.js

@@ -5,6 +5,7 @@ const MongoError = require('../error').MongoError;
 const MongoNetworkError = require('../error').MongoNetworkError;
 const collectionNamespace = require('./shared').collectionNamespace;
 const maxWireVersion = require('../utils').maxWireVersion;
+const emitWarning = require('../utils').emitWarning;
 const command = require('./command');
 
 function killCursors(server, ns, cursorState, callback) {
@@ -31,7 +32,7 @@ function killCursors(server, ns, cursorState, callback) {
         if (typeof callback === 'function') {
           callback(err, null);
         } else {
-          console.warn(err);
+          emitWarning(err);
         }
       }
     }

package/lib/db.js

@@ -12,7 +12,7 @@ const MongoError = require('./core').MongoError;
 const ObjectID = require('./core').ObjectID;
 const Logger = require('./core').Logger;
 const Collection = require('./collection');
-const mergeOptionsAndWriteConcern = require('./utils').mergeOptionsAndWriteConcern;
+const conditionallyMergeWriteConcern = require('./utils').conditionallyMergeWriteConcern;
 const executeLegacyOperation = require('./utils').executeLegacyOperation;
 const ChangeStream = require('./change_stream');
 const deprecate = require('util').deprecate;
@@ -382,7 +382,7 @@ Db.prototype.admin = function() {
  * @param {AggregationCursor} cursor The cursor if the aggregation command was executed successfully.
  */
 
-const collectionKeys = [
+const COLLECTION_OPTION_KEYS = [
   'pkFactory',
   'readPreference',
   'serializeFunctions',
@@ -433,8 +433,14 @@ Db.prototype.collection = function(name, options, callback) {
     options.ignoreUndefined = this.s.options.ignoreUndefined;
   }
 
+  for (const collectionOptionKey of COLLECTION_OPTION_KEYS) {
+    if (!(collectionOptionKey in options) && this.s.options[collectionOptionKey] !== undefined) {
+      options[collectionOptionKey] = this.s.options[collectionOptionKey];
+    }
+  }
+
   // Merge in all needed options and ensure correct writeConcern merging from db level
-  options = mergeOptionsAndWriteConcern(options, this.s.options, collectionKeys, true);
+  options = conditionallyMergeWriteConcern(options, this.s.options);
 
   // Execute
   if (options == null || !options.strict) {

package/lib/mongo_client.js

@@ -457,10 +457,6 @@ MongoClient.prototype.startSession = function(options) {
     throw new MongoError('Must connect to a server before calling this method');
   }
 
-  if (!this.topology.hasSessionSupport()) {
-    throw new MongoError('Current topology does not support sessions');
-  }
-
   return this.topology.startSession(options, this.s.options);
 };
 

package/lib/operations/add_user.js

@@ -6,6 +6,7 @@ const defineAspects = require('./operation').defineAspects;
 const crypto = require('crypto');
 const handleCallback = require('../utils').handleCallback;
 const toError = require('../utils').toError;
+const emitWarning = require('../utils').emitWarning;
 
 class AddUserOperation extends CommandOperation {
   constructor(db, username, password, options) {
@@ -29,7 +30,7 @@ class AddUserOperation extends CommandOperation {
     // If not roles defined print deprecated message
     // TODO: handle deprecation properly
     if (roles.length === 0) {
-      console.log('Creating a user without roles is deprecated in MongoDB >= 2.6');
+      emitWarning('Creating a user without roles is deprecated in MongoDB >= 2.6');
     }
 
     // Check the db name and add roles if needed

package/lib/operations/connect.js

@@ -13,6 +13,7 @@ const ReplSet = require('../topologies/replset');
 const Server = require('../topologies/server');
 const ServerSessionPool = require('../core').Sessions.ServerSessionPool;
 const emitDeprecationWarning = require('../utils').emitDeprecationWarning;
+const emitWarningOnce = require('../utils').emitWarningOnce;
 const fs = require('fs');
 const WriteConcern = require('../write_concern');
 const BSON = require('../core/connection/utils').retrieveBSON();
@@ -182,12 +183,12 @@ function validOptions(options) {
       if (options.validateOptions) {
         return new MongoError(`option ${name} is not supported`);
       } else {
-        console.warn(`the options [${name}] is not supported`);
+        emitWarningOnce(`the options [${name}] is not supported`);
       }
     }
 
     if (legacyOptionNames.indexOf(name) !== -1) {
-      console.warn(
+      emitWarningOnce(
         `the server/replset/mongos/db options are deprecated, ` +
           `all their options are supported at the top level of the options object [${validOptionNames}]`
       );
@@ -257,9 +258,6 @@ function resolveTLSOptions(options) {
   });
 }
 
-const emitDeprecationForNonUnifiedTopology = deprecate(() => {},
-'current Server Discovery and Monitoring engine is deprecated, and will be removed in a future version. ' + 'To use the new Server Discover and Monitoring engine, pass option { useUnifiedTopology: true } to the MongoClient constructor.');
-
 function connect(mongoClient, url, options, callback) {
   options = Object.assign({}, options);
 
@@ -335,7 +333,9 @@ function connect(mongoClient, url, options, callback) {
       return createTopology(mongoClient, 'unified', _finalOptions, connectCallback);
     }
 
-    emitDeprecationForNonUnifiedTopology();
+    emitWarningOnce(
+      'Current Server Discovery and Monitoring engine is deprecated, and will be removed in a future version. To use the new Server Discover and Monitoring engine, pass option { useUnifiedTopology: true } to the MongoClient constructor.'
+    );
 
     // Do we have a replicaset then skip discovery and go straight to connectivity
     if (_finalOptions.replicaSet || _finalOptions.rs_name) {

package/lib/operations/execute_operation.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const maybePromise = require('../utils').maybePromise;
 const MongoError = require('../core/error').MongoError;
 const Aspect = require('./operation').Aspect;
 const OperationBase = require('./operation').OperationBase;
@@ -21,7 +22,7 @@ const isUnifiedTopology = require('../core/utils').isUnifiedTopology;
  * @param {Operation} operation The operation to execute
  * @param {function} callback The command result callback
  */
-function executeOperation(topology, operation, callback) {
+function executeOperation(topology, operation, cb) {
   if (topology == null) {
     throw new TypeError('This method requires a valid topology instance');
   }
@@ -30,64 +31,57 @@ function executeOperation(topology, operation, callback) {
     throw new TypeError('This method requires a valid operation instance');
   }
 
-  if (isUnifiedTopology(topology) && topology.shouldCheckForSessionSupport()) {
-    return selectServerForSessionSupport(topology, operation, callback);
-  }
-
-  const Promise = topology.s.promiseLibrary;
-
-  // The driver sessions spec mandates that we implicitly create sessions for operations
-  // that are not explicitly provided with a session.
-  let session, owner;
-  if (topology.hasSessionSupport()) {
-    if (operation.session == null) {
-      owner = Symbol();
-      session = topology.startSession({ owner });
-      operation.session = session;
-    } else if (operation.session.hasEnded) {
-      throw new MongoError('Use of expired sessions is not permitted');
+  return maybePromise(topology, cb, callback => {
+    if (isUnifiedTopology(topology) && topology.shouldCheckForSessionSupport()) {
+      // Recursive call to executeOperation after a server selection
+      return selectServerForSessionSupport(topology, operation, callback);
     }
-  }
-
-  let result;
-  if (typeof callback !== 'function') {
-    result = new Promise((resolve, reject) => {
-      callback = (err, res) => {
-        if (err) return reject(err);
-        resolve(res);
-      };
-    });
-  }
 
-  function executeCallback(err, result) {
-    if (session && session.owner === owner) {
-      session.endSession();
-      if (operation.session === session) {
-        operation.clearSession();
+    // The driver sessions spec mandates that we implicitly create sessions for operations
+    // that are not explicitly provided with a session.
+    let session, owner;
+    if (topology.hasSessionSupport()) {
+      if (operation.session == null) {
+        owner = Symbol();
+        session = topology.startSession({ owner });
+        operation.session = session;
+      } else if (operation.session.hasEnded) {
+        return callback(new MongoError('Use of expired sessions is not permitted'));
       }
+    } else if (operation.session) {
+      // If the user passed an explicit session and we are still, after server selection,
+      // trying to run against a topology that doesn't support sessions we error out.
+      return callback(new MongoError('Current topology does not support sessions'));
     }
 
-    callback(err, result);
-  }
-
-  try {
-    if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
-      executeWithServerSelection(topology, operation, executeCallback);
-    } else {
-      operation.execute(executeCallback);
-    }
-  } catch (e) {
-    if (session && session.owner === owner) {
-      session.endSession();
-      if (operation.session === session) {
-        operation.clearSession();
+    function executeCallback(err, result) {
+      if (session && session.owner === owner) {
+        session.endSession();
+        if (operation.session === session) {
+          operation.clearSession();
+        }
       }
+
+      callback(err, result);
     }
 
-    throw e;
-  }
+    try {
+      if (operation.hasAspect(Aspect.EXECUTE_WITH_SELECTION)) {
+        executeWithServerSelection(topology, operation, executeCallback);
+      } else {
+        operation.execute(executeCallback);
+      }
+    } catch (error) {
+      if (session && session.owner === owner) {
+        session.endSession();
+        if (operation.session === session) {
+          operation.clearSession();
+        }
+      }
 
-  return result;
+      callback(error);
+    }
+  });
 }
 
 function supportsRetryableReads(server) {
@@ -139,7 +133,6 @@ function executeWithServerSelection(topology, operation, callback) {
       callback(err, null);
       return;
     }
-
     const shouldRetryReads =
       topology.s.options.retryReads !== false &&
       operation.session &&
@@ -156,31 +149,16 @@ function executeWithServerSelection(topology, operation, callback) {
   });
 }
 
-// TODO: This is only supported for unified topology, it should go away once
-//       we remove support for legacy topology types.
+// The Unified Topology runs serverSelection before executing every operation
+// Session support is determined by the result of a monitoring check triggered by this selection
 function selectServerForSessionSupport(topology, operation, callback) {
-  const Promise = topology.s.promiseLibrary;
-
-  let result;
-  if (typeof callback !== 'function') {
-    result = new Promise((resolve, reject) => {
-      callback = (err, result) => {
-        if (err) return reject(err);
-        resolve(result);
-      };
-    });
-  }
-
   topology.selectServer(ReadPreference.primaryPreferred, err => {
     if (err) {
-      callback(err);
-      return;
+      return callback(err);
     }
 
     executeOperation(topology, operation, callback);
   });
-
-  return result;
 }
 
 module.exports = executeOperation;

package/lib/operations/operation.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const Explain = require('../explain').Explain;
-const MongoError = require('../core').MongoError;
+const MongoError = require('../core/error').MongoError;
 
 const Aspect = {
   READ_OPERATION: Symbol('READ_OPERATION'),

package/lib/utils.js

@@ -287,39 +287,38 @@ var filterOptions = function(options, names) {
 };
 
 // Write concern keys
-var writeConcernKeys = ['w', 'j', 'wtimeout', 'fsync'];
+const WRITE_CONCERN_KEYS = ['w', 'j', 'wtimeout', 'fsync', 'writeConcern'];
 
-// Merge the write concern options
-var mergeOptionsAndWriteConcern = function(targetOptions, sourceOptions, keys, mergeWriteConcern) {
-  // Mix in any allowed options
-  for (var i = 0; i < keys.length; i++) {
-    if (!targetOptions[keys[i]] && sourceOptions[keys[i]] !== undefined) {
-      targetOptions[keys[i]] = sourceOptions[keys[i]];
-    }
-  }
-
-  // No merging of write concern
-  if (!mergeWriteConcern) return targetOptions;
-
-  // Found no write Concern options
-  var found = false;
-  for (i = 0; i < writeConcernKeys.length; i++) {
-    if (targetOptions[writeConcernKeys[i]]) {
+/**
+ * If there is no WriteConcern related options defined on target then inherit from source.
+ * Otherwise, do not inherit **any** options from source.
+ * @internal
+ * @param {object} target - options object conditionally receiving the writeConcern options
+ * @param {object} source - options object containing the potentially inherited writeConcern options
+ */
+function conditionallyMergeWriteConcern(target, source) {
+  let found = false;
+  for (const wcKey of WRITE_CONCERN_KEYS) {
+    if (wcKey in target) {
+      // Found a writeConcern option
       found = true;
       break;
     }
   }
 
   if (!found) {
-    for (i = 0; i < writeConcernKeys.length; i++) {
-      if (sourceOptions[writeConcernKeys[i]]) {
-        targetOptions[writeConcernKeys[i]] = sourceOptions[writeConcernKeys[i]];
+    for (const wcKey of WRITE_CONCERN_KEYS) {
+      if (source[wcKey]) {
+        if (!('writeConcern' in target)) {
+          target.writeConcern = {};
+        }
+        target.writeConcern[wcKey] = source[wcKey];
       }
     }
   }
 
-  return targetOptions;
-};
+  return target;
+}
 
 /**
  * Executes the given operation with provided arguments.
@@ -534,7 +533,12 @@ function decorateWithExplain(command, explain) {
   return { explain: command, verbosity: explain.verbosity };
 }
 
-const emitProcessWarning = msg => process.emitWarning(msg, 'DeprecationWarning');
+const nodejsMajorVersion = +process.version.split('.')[0].substring(1);
+const emitProcessWarning = msg =>
+  nodejsMajorVersion <= 6
+    ? process.emitWarning(msg, 'DeprecationWarning', MONGODB_WARNING_CODE)
+    : process.emitWarning(msg, { type: 'DeprecationWarning', code: MONGODB_WARNING_CODE });
+// eslint-disable-next-line no-console
 const emitConsoleWarning = msg => console.error(msg);
 const emitDeprecationWarning = process.emitWarning ? emitProcessWarning : emitConsoleWarning;
 
@@ -816,6 +820,50 @@ function hasAtomicOperators(doc) {
   );
 }
 
+/**
+ * When the driver used emitWarning the code will be equal to this.
+ * @public
+ *
+ * @example
+ * ```js
+ * process.on('warning', (warning) => {
+ *  if (warning.code === MONGODB_WARNING_CODE) console.error('Ah an important warning! :)')
+ * })
+ * ```
+ */
+const MONGODB_WARNING_CODE = 'MONGODB DRIVER';
+
+/**
+ * @internal
+ * @param {string} message - message to warn about
+ */
+function emitWarning(message) {
+  if (process.emitWarning) {
+    return nodejsMajorVersion <= 6
+      ? process.emitWarning(message, undefined, MONGODB_WARNING_CODE)
+      : process.emitWarning(message, { code: MONGODB_WARNING_CODE });
+  } else {
+    // Approximate the style of print out on node versions pre 8.x
+    // eslint-disable-next-line no-console
+    return console.error(`[${MONGODB_WARNING_CODE}] Warning:`, message);
+  }
+}
+
+const emittedWarnings = new Set();
+/**
+ * Will emit a warning once for the duration of the application.
+ * Uses the message to identify if it has already been emitted
+ * so using string interpolation can cause multiple emits
+ * @internal
+ * @param {string} message - message to warn about
+ */
+function emitWarningOnce(message) {
+  if (!emittedWarnings.has(message)) {
+    emittedWarnings.add(message);
+    return emitWarning(message);
+  }
+}
+
 module.exports = {
   filterOptions,
   mergeOptions,
@@ -832,7 +880,7 @@ module.exports = {
   isObject,
   debugOptions,
   MAX_JS_INT: Number.MAX_SAFE_INTEGER + 1,
-  mergeOptionsAndWriteConcern,
+  conditionallyMergeWriteConcern,
   executeLegacyOperation,
   applyRetryableWrites,
   applyWriteConcern,
@@ -849,5 +897,8 @@ module.exports = {
   now,
   calculateDurationInMs,
   makeInterruptableAsyncInterval,
-  hasAtomicOperators
+  hasAtomicOperators,
+  MONGODB_WARNING_CODE,
+  emitWarning,
+  emitWarningOnce
 };

package/lib/write_concern.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const kWriteConcernKeys = new Set(['w', 'wtimeout', 'j', 'journal', 'fsync']);
+let utils;
 
 /**
  * The **WriteConcern** class is a class that represents a MongoDB WriteConcern.
@@ -75,7 +76,10 @@ class WriteConcern {
       );
     }
 
-    console.warn(
+    // this is down here to prevent circular dependency
+    if (!utils) utils = require('./utils');
+
+    utils.emitWarningOnce(
       `Top-level use of w, wtimeout, j, and fsync is deprecated. Use writeConcern instead.`
     );
     return new WriteConcern(

package/package.json

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