mongodb 3.6.12 → 3.7.0

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/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);
   }
 }
 

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

@@ -1532,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.' +

package/lib/core/connection/connect.js

@@ -108,6 +108,11 @@ function performInitialHandshake(conn, options, _callback) {
         return;
       }
 
+      if ('isWritablePrimary' in response) {
+        // Provide pre-hello-style response document.
+        response.ismaster = response.isWritablePrimary;
+      }
+
       const supportedServerErr = checkSupportedServer(response, options);
       if (supportedServerErr) {
         callback(supportedServerErr);
@@ -158,11 +163,12 @@ function performInitialHandshake(conn, options, _callback) {
 
 function prepareHandshakeDocument(authContext, callback) {
   const options = authContext.options;
+  const serverApi = authContext.connection.serverApi;
   const compressors =
     options.compression && options.compression.compressors ? options.compression.compressors : [];
 
   const handshakeDoc = {
-    ismaster: true,
+    [serverApi ? 'hello' : 'ismaster']: true,
     client: options.metadata || makeClientMetadata(options),
     compression: compressors
   };

package/lib/core/index.js

@@ -15,7 +15,16 @@ try {
   }
 } catch (err) {} // eslint-disable-line
 
+/** An enumeration of valid server API versions */
+const ServerApiVersion = Object.freeze({
+  v1: '1'
+});
+const ValidServerApiVersions = Object.keys(ServerApiVersion).map(key => ServerApiVersion[key]);
+
 module.exports = {
+  // Versioned API
+  ServerApiVersion,
+  ValidServerApiVersions,
   // Errors
   MongoError: require('./error').MongoError,
   MongoNetworkError: require('./error').MongoNetworkError,

package/lib/core/sdam/monitor.js

@@ -204,8 +204,9 @@ function checkServer(monitor, callback) {
     const maxAwaitTimeMS = monitor.options.heartbeatFrequencyMS;
     const topologyVersion = monitor[kServer].description.topologyVersion;
     const isAwaitable = topologyVersion != null;
+    const serverApi = monitor[kConnection].serverApi;
 
-    const cmd = { ismaster: true };
+    const cmd = { [serverApi ? 'hello' : 'ismaster']: true };
     const options = { socketTimeout: connectTimeoutMS };
 
     if (isAwaitable) {
@@ -229,6 +230,11 @@ function checkServer(monitor, callback) {
       const isMaster = result.result;
       const rttPinger = monitor[kRTTPinger];
 
+      if ('isWritablePrimary' in isMaster) {
+        // Provide pre-hello-style response document.
+        isMaster.ismaster = isMaster.isWritablePrimary;
+      }
+
       const duration =
         isAwaitable && rttPinger ? rttPinger.roundTripTime : calculateDurationInMs(start);
 

package/lib/core/sdam/server.js

@@ -114,6 +114,7 @@ class Server extends EventEmitter {
       credentials: options.credentials,
       topology
     };
+    this.serverApi = options.serverApi;
 
     // create the connection pool
     // NOTE: this used to happen in `connect`, we supported overriding pool options there
@@ -251,6 +252,7 @@ class Server extends EventEmitter {
     if (typeof options === 'function') {
       (callback = options), (options = {}), (options = options || {});
     }
+    options.serverApi = this.serverApi;
 
     if (this.s.state === STATE_CLOSING || this.s.state === STATE_CLOSED) {
       callback(new MongoError('server is closed'));

package/lib/core/sdam/topology.js

@@ -200,6 +200,7 @@ class Topology extends EventEmitter {
       // timer management
       connectionTimers: new Set()
     };
+    this.serverApi = options.serverApi;
 
     if (options.srvHost) {
       this.s.srvPoller =
@@ -494,7 +495,11 @@ class Topology extends EventEmitter {
     this.command(
       'admin.$cmd',
       { endSessions: sessions },
-      { readPreference: ReadPreference.primaryPreferred, noResponse: true },
+      {
+        readPreference: ReadPreference.primaryPreferred,
+        noResponse: true,
+        serverApi: this.serverApi
+      },
       () => {
         // intentionally ignored, per spec
         if (typeof callback === 'function') callback();

package/lib/core/sessions.js

@@ -472,17 +472,20 @@ function endTransaction(session, commandName, callback) {
     if (commandName === 'commitTransaction') {
       session.transaction.transition(TxnState.TRANSACTION_COMMITTED);
 
-      if (
-        e &&
-        (e instanceof MongoNetworkError ||
+      if (e) {
+        if (
+          e instanceof MongoNetworkError ||
           e instanceof MongoWriteConcernError ||
           isRetryableError(e) ||
-          isMaxTimeMSExpiredError(e))
-      ) {
-        if (isUnknownTransactionCommitResult(e)) {
-          e.addErrorLabel('UnknownTransactionCommitResult');
+          isMaxTimeMSExpiredError(e)
+        ) {
+          if (isUnknownTransactionCommitResult(e)) {
+            e.addErrorLabel('UnknownTransactionCommitResult');
 
-          // per txns spec, must unpin session in this case
+            // per txns spec, must unpin session in this case
+            session.transaction.unpinServer();
+          }
+        } else if (e.hasErrorLabel('TransientTransactionError')) {
           session.transaction.unpinServer();
         }
       }

package/lib/core/transactions.js

@@ -150,7 +150,11 @@ class Transaction {
     const nextStates = stateMachine[this.state];
     if (nextStates && nextStates.indexOf(nextState) !== -1) {
       this.state = nextState;
-      if (this.state === TxnState.NO_TRANSACTION || this.state === TxnState.STARTING_TRANSACTION) {
+      if (
+        this.state === TxnState.NO_TRANSACTION ||
+        this.state === TxnState.STARTING_TRANSACTION ||
+        this.state === TxnState.TRANSACTION_ABORTED
+      ) {
         this.unpinServer();
       }
       return;

package/lib/core/uri_parser.js

@@ -432,6 +432,11 @@ function parseQueryString(query, options) {
     }
 
     const normalizedKey = key.toLowerCase();
+    if (normalizedKey === 'serverapi') {
+      throw new MongoParseError(
+        'URI cannot contain `serverApi`, it can only be passed to the client'
+      );
+    }
     const parsedValue = FILE_PATH_OPTIONS.has(normalizedKey)
       ? value
       : parseQueryStringItemValue(normalizedKey, value);

package/lib/core/wireprotocol/command.js

@@ -48,6 +48,18 @@ function _command(server, ns, cmd, options, callback) {
   const serverClusterTime = server.clusterTime;
   let clusterTime = serverClusterTime;
   let finalCmd = Object.assign({}, cmd);
+
+  const serverApi = options.serverApi;
+  if (serverApi) {
+    finalCmd.apiVersion = serverApi.version || serverApi;
+    if (serverApi.strict != null) {
+      finalCmd.apiStrict = serverApi.strict;
+    }
+    if (serverApi.deprecationErrors != null) {
+      finalCmd.apiDeprecationErrors = serverApi.deprecationErrors;
+    }
+  }
+
   if (hasSessionSupport(server) && session) {
     const sessionClusterTime = session.clusterTime;
     if (
@@ -60,6 +72,18 @@ function _command(server, ns, cmd, options, callback) {
       clusterTime = sessionClusterTime;
     }
 
+    // We need to unpin any read or write commands that happen outside of a pinned
+    // transaction, so we check if we have a pinned transaction that is no longer
+    // active, and unpin for all except start or commit.
+    if (
+      !session.transaction.isActive &&
+      session.transaction.isPinned &&
+      !finalCmd.startTransaction &&
+      !finalCmd.commitTransaction
+    ) {
+      session.transaction.unpinServer();
+    }
+
     const err = applySession(session, finalCmd, options);
     if (err) {
       return callback(err);

package/lib/core/wireprotocol/kill_cursors.js

@@ -8,8 +8,13 @@ const maxWireVersion = require('../utils').maxWireVersion;
 const emitWarning = require('../utils').emitWarning;
 const command = require('./command');
 
-function killCursors(server, ns, cursorState, callback) {
+function killCursors(server, ns, cursorState, defaultOptions, callback) {
+  if (typeof defaultOptions === 'function') {
+    callback = defaultOptions;
+    defaultOptions = {};
+  }
   callback = typeof callback === 'function' ? callback : () => {};
+
   const cursorId = cursorState.cursorId;
 
   if (maxWireVersion(server) < 4) {
@@ -45,7 +50,7 @@ function killCursors(server, ns, cursorState, callback) {
     cursors: [cursorId]
   };
 
-  const options = {};
+  const options = defaultOptions || {};
   if (typeof cursorState.session === 'object') options.session = cursorState.session;
 
   command(server, ns, killCursorCmd, options, (err, result) => {

package/lib/core/wireprotocol/query.js

@@ -37,9 +37,13 @@ function query(server, ns, cmd, cursorState, options, callback) {
 
   // If we have explain, we need to rewrite the find command
   // to wrap it in the explain command
-  const explain = Explain.fromOptions(options);
-  if (explain) {
-    findCmd = decorateWithExplain(findCmd, explain);
+  try {
+    const explain = Explain.fromOptions(options);
+    if (explain) {
+      findCmd = decorateWithExplain(findCmd, explain);
+    }
+  } catch (err) {
+    return callback(err);
   }
 
   // NOTE: This actually modifies the passed in cmd, and our code _depends_ on this
@@ -140,8 +144,8 @@ function prepareFindCommand(server, ns, cmd, cursorState) {
   if (cmd.maxTimeMS) findCmd.maxTimeMS = cmd.maxTimeMS;
   if (cmd.min) findCmd.min = cmd.min;
   if (cmd.max) findCmd.max = cmd.max;
-  findCmd.returnKey = cmd.returnKey ? cmd.returnKey : false;
-  findCmd.showRecordId = cmd.showDiskLoc ? cmd.showDiskLoc : false;
+  if (typeof cmd.returnKey === 'boolean') findCmd.returnKey = cmd.returnKey;
+  if (typeof cmd.showDiskLoc === 'boolean') findCmd.showRecordId = cmd.showDiskLoc;
   if (cmd.snapshot) findCmd.snapshot = cmd.snapshot;
   if (cmd.tailable) findCmd.tailable = cmd.tailable;
   if (cmd.oplogReplay) findCmd.oplogReplay = cmd.oplogReplay;

package/lib/cursor.js

@@ -165,6 +165,10 @@ class Cursor extends CoreCursor {
     return this.cmd.sort;
   }
 
+  set session(clientSession) {
+    this.cursorState.session = clientSession;
+  }
+
   _initializeCursor(callback) {
     if (this.operation && this.operation.session != null) {
       this.cursorState.session = this.operation.session;

package/lib/explain.js

@@ -2,16 +2,9 @@
 
 const MongoError = require('./core/error').MongoError;
 
-const ExplainVerbosity = {
-  queryPlanner: 'queryPlanner',
-  queryPlannerExtended: 'queryPlannerExtended',
-  executionStats: 'executionStats',
-  allPlansExecution: 'allPlansExecution'
-};
-
 /**
  * @class
- * @property {'queryPlanner'|'queryPlannerExtended'|'executionStats'|'allPlansExecution'} verbosity The verbosity mode for the explain output.
+ * @property {string} verbosity The verbosity mode for the explain output, e.g.: 'queryPlanner', 'queryPlannerExtended', 'executionStats', 'allPlansExecution'.
  */
 class Explain {
   /**
@@ -21,7 +14,7 @@ class Explain {
    * and false as "queryPlanner". Prior to server version 3.6, aggregate()
    * ignores the verbosity parameter and executes in "queryPlanner".
    *
-   * @param {'queryPlanner'|'queryPlannerExtended'|'executionStats'|'allPlansExecution'|boolean} [verbosity] The verbosity mode for the explain output.
+   * @param {string|boolean} [verbosity] The verbosity mode for the explain output.
    */
   constructor(verbosity) {
     if (typeof verbosity === 'boolean') {
@@ -35,7 +28,7 @@ class Explain {
    * Construct an Explain given an options object.
    *
    * @param {object} [options] The options object from which to extract the explain.
-   * @param {'queryPlanner'|'queryPlannerExtended'|'executionStats'|'allPlansExecution'|boolean} [options.explain] The verbosity mode for the explain output
+   * @param {string|boolean} [options.explain] The verbosity mode for the explain output.
    * @return {Explain}
    */
   static fromOptions(options) {
@@ -44,11 +37,11 @@ class Explain {
     }
 
     const explain = options.explain;
-    if (typeof explain === 'boolean' || explain in ExplainVerbosity) {
+    if (typeof explain === 'boolean' || typeof explain === 'string') {
       return new Explain(options.explain);
     }
 
-    throw new MongoError(`explain must be one of ${Object.keys(ExplainVerbosity)} or a boolean`);
+    throw new MongoError(`explain must be a string or a boolean`);
   }
 }
 

package/lib/gridfs-stream/index.js

@@ -7,6 +7,7 @@ var shallowClone = require('../utils').shallowClone;
 var toError = require('../utils').toError;
 var util = require('util');
 var executeLegacyOperation = require('../utils').executeLegacyOperation;
+const deprecateOptions = require('../utils').deprecateOptions;
 
 var DEFAULT_GRIDFS_BUCKET_OPTIONS = {
   bucketName: 'fs',
@@ -79,21 +80,28 @@ util.inherits(GridFSBucket, Emitter);
  * @param {object} [options.metadata] Optional object to store in the file document's `metadata` field
  * @param {string} [options.contentType] Optional string to store in the file document's `contentType` field
  * @param {array} [options.aliases] Optional array of strings to store in the file document's `aliases` field
- * @param {boolean} [options.disableMD5=false] If true, disables adding an md5 field to file data
+ * @param {boolean} [options.disableMD5=false] **Deprecated** If true, disables adding an md5 field to file data
  * @return {GridFSBucketWriteStream}
  */
 
-GridFSBucket.prototype.openUploadStream = function(filename, options) {
-  if (options) {
-    options = shallowClone(options);
-  } else {
-    options = {};
-  }
-  if (!options.chunkSizeBytes) {
-    options.chunkSizeBytes = this.s.options.chunkSizeBytes;
+GridFSBucket.prototype.openUploadStream = deprecateOptions(
+  {
+    name: 'GridFSBucket.openUploadStream',
+    deprecatedOptions: ['disableMD5'],
+    optionsIndex: 1
+  },
+  function(filename, options) {
+    if (options) {
+      options = shallowClone(options);
+    } else {
+      options = {};
+    }
+    if (!options.chunkSizeBytes) {
+      options.chunkSizeBytes = this.s.options.chunkSizeBytes;
+    }
+    return new GridFSBucketWriteStream(this, filename, options);
   }
-  return new GridFSBucketWriteStream(this, filename, options);
-};
+);
 
 /**
  * Returns a writable stream (GridFSBucketWriteStream) for writing
@@ -107,25 +115,32 @@ GridFSBucket.prototype.openUploadStream = function(filename, options) {
  * @param {object} [options.metadata] Optional object to store in the file document's `metadata` field
  * @param {string} [options.contentType] Optional string to store in the file document's `contentType` field
  * @param {array} [options.aliases] Optional array of strings to store in the file document's `aliases` field
- * @param {boolean} [options.disableMD5=false] If true, disables adding an md5 field to file data
+ * @param {boolean} [options.disableMD5=false] **Deprecated** If true, disables adding an md5 field to file data
  * @return {GridFSBucketWriteStream}
  */
 
-GridFSBucket.prototype.openUploadStreamWithId = function(id, filename, options) {
-  if (options) {
-    options = shallowClone(options);
-  } else {
-    options = {};
-  }
+GridFSBucket.prototype.openUploadStreamWithId = deprecateOptions(
+  {
+    name: 'GridFSBucket.openUploadStreamWithId',
+    deprecatedOptions: ['disableMD5'],
+    optionsIndex: 2
+  },
+  function(id, filename, options) {
+    if (options) {
+      options = shallowClone(options);
+    } else {
+      options = {};
+    }
 
-  if (!options.chunkSizeBytes) {
-    options.chunkSizeBytes = this.s.options.chunkSizeBytes;
-  }
+    if (!options.chunkSizeBytes) {
+      options.chunkSizeBytes = this.s.options.chunkSizeBytes;
+    }
 
-  options.id = id;
+    options.id = id;
 
-  return new GridFSBucketWriteStream(this, filename, options);
-};
+    return new GridFSBucketWriteStream(this, filename, options);
+  }
+);
 
 /**
  * Returns a readable stream (GridFSBucketReadStream) for streaming file

package/lib/gridfs-stream/upload.js

@@ -5,10 +5,9 @@ var crypto = require('crypto');
 var stream = require('stream');
 var util = require('util');
 var Buffer = require('safe-buffer').Buffer;
+const deprecateOptions = require('../utils').deprecateOptions;
 
-var ERROR_NAMESPACE_NOT_FOUND = 26;
-
-module.exports = GridFSBucketWriteStream;
+const ERROR_NAMESPACE_NOT_FOUND = 26;
 
 /**
  * A writable stream that enables you to write buffers to GridFS.
@@ -31,42 +30,49 @@ module.exports = GridFSBucketWriteStream;
  * @fires GridFSBucketWriteStream#finish
  */
 
-function GridFSBucketWriteStream(bucket, filename, options) {
-  options = options || {};
-  stream.Writable.call(this, options);
-  this.bucket = bucket;
-  this.chunks = bucket.s._chunksCollection;
-  this.filename = filename;
-  this.files = bucket.s._filesCollection;
-  this.options = options;
-  // Signals the write is all done
-  this.done = false;
-
-  this.id = options.id ? options.id : core.BSON.ObjectId();
-  this.chunkSizeBytes = this.options.chunkSizeBytes;
-  this.bufToStore = Buffer.alloc(this.chunkSizeBytes);
-  this.length = 0;
-  this.md5 = !options.disableMD5 && crypto.createHash('md5');
-  this.n = 0;
-  this.pos = 0;
-  this.state = {
-    streamEnd: false,
-    outstandingRequests: 0,
-    errored: false,
-    aborted: false,
-    promiseLibrary: this.bucket.s.promiseLibrary
-  };
-
-  if (!this.bucket.s.calledOpenUploadStream) {
-    this.bucket.s.calledOpenUploadStream = true;
-
-    var _this = this;
-    checkIndexes(this, function() {
-      _this.bucket.s.checkedIndexes = true;
-      _this.bucket.emit('index');
-    });
+const GridFSBucketWriteStream = deprecateOptions(
+  {
+    name: 'GridFSBucketWriteStream',
+    deprecatedOptions: ['disableMD5'],
+    optionsIndex: 2
+  },
+  function(bucket, filename, options) {
+    options = options || {};
+    stream.Writable.call(this, options);
+    this.bucket = bucket;
+    this.chunks = bucket.s._chunksCollection;
+    this.filename = filename;
+    this.files = bucket.s._filesCollection;
+    this.options = options;
+    // Signals the write is all done
+    this.done = false;
+
+    this.id = options.id ? options.id : core.BSON.ObjectId();
+    this.chunkSizeBytes = this.options.chunkSizeBytes;
+    this.bufToStore = Buffer.alloc(this.chunkSizeBytes);
+    this.length = 0;
+    this.md5 = !options.disableMD5 && crypto.createHash('md5');
+    this.n = 0;
+    this.pos = 0;
+    this.state = {
+      streamEnd: false,
+      outstandingRequests: 0,
+      errored: false,
+      aborted: false,
+      promiseLibrary: this.bucket.s.promiseLibrary
+    };
+
+    if (!this.bucket.s.calledOpenUploadStream) {
+      this.bucket.s.calledOpenUploadStream = true;
+
+      var _this = this;
+      checkIndexes(this, function() {
+        _this.bucket.s.checkedIndexes = true;
+        _this.bucket.emit('index');
+      });
+    }
   }
-}
+);
 
 util.inherits(GridFSBucketWriteStream, stream.Writable);
 
@@ -539,3 +545,5 @@ function checkAborted(_this, callback) {
   }
   return false;
 }
+
+module.exports = GridFSBucketWriteStream;

package/lib/mongo_client.js

@@ -5,6 +5,7 @@ const Db = require('./db');
 const EventEmitter = require('events').EventEmitter;
 const inherits = require('util').inherits;
 const MongoError = require('./core').MongoError;
+const ValidServerApiVersions = require('./core').ValidServerApiVersions;
 const deprecate = require('util').deprecate;
 const WriteConcern = require('./write_concern');
 const MongoDBNamespace = require('./utils').MongoDBNamespace;
@@ -156,6 +157,7 @@ const validOptions = require('./operations/connect').validOptions;
  * @property {number} [numberOfRetries] (**default**: 5) The number of retries for a tailable cursor
  * @property {boolean} [auto_reconnect] (**default**: true) Enable auto reconnecting for single server instances
  * @property {boolean} [monitorCommands] (**default**: false) Enable command monitoring for this client
+ * @property {string|ServerApi} [serverApi] (**default**: undefined) The server API version
  * @property {number} [minSize] If present, the connection pool will be initialized with minSize connections, and will never dip below minSize connections
  * @property {boolean} [useNewUrlParser] (**default**: true) Determines whether or not to use the new url parser. Enables the new, spec-compliant, url parser shipped in the core driver. This url parser fixes a number of problems with the original parser, and aims to outright replace that parser in the near future. Defaults to true, and must be explicitly set to false to use the legacy url parser.
  * @property {boolean} [useUnifiedTopology] Enables the new unified topology layer
@@ -191,16 +193,38 @@ const validOptions = require('./operations/connect').validOptions;
  * @param {MongoClientOptions} [options] Optional settings
  */
 function MongoClient(url, options) {
+  options = options || {};
   if (!(this instanceof MongoClient)) return new MongoClient(url, options);
   // Set up event emitter
   EventEmitter.call(this);
 
-  if (options && options.autoEncryption) require('./encrypter'); // Does CSFLE lib check
+  if (options.autoEncryption) require('./encrypter'); // Does CSFLE lib check
+
+  if (options.serverApi) {
+    const serverApiToValidate =
+      typeof options.serverApi === 'string' ? { version: options.serverApi } : options.serverApi;
+    const versionToValidate = serverApiToValidate && serverApiToValidate.version;
+    if (!versionToValidate) {
+      throw new MongoError(
+        `Invalid \`serverApi\` property; must specify a version from the following enum: ["${ValidServerApiVersions.join(
+          '", "'
+        )}"]`
+      );
+    }
+    if (!ValidServerApiVersions.some(v => v === versionToValidate)) {
+      throw new MongoError(
+        `Invalid server API version=${versionToValidate}; must be in the following enum: ["${ValidServerApiVersions.join(
+          '", "'
+        )}"]`
+      );
+    }
+    options.serverApi = serverApiToValidate;
+  }
 
   // The internal state
   this.s = {
-    url: url,
-    options: options || {},
+    url,
+    options,
     promiseLibrary: (options && options.promiseLibrary) || Promise,
     dbCache: new Map(),
     sessions: new Set(),
@@ -364,17 +388,18 @@ MongoClient.prototype.db = function(dbName, options) {
  * Check if MongoClient is connected
  *
  * @method
+ * @deprecated
  * @param {object} [options] Optional settings.
  * @param {boolean} [options.noListener=false] Do not make the db an event listener to the original connection.
  * @param {boolean} [options.returnNonCachedInstance=false] Control if you want to return a cached instance or have a new one created
  * @return {boolean}
  */
-MongoClient.prototype.isConnected = function(options) {
+MongoClient.prototype.isConnected = deprecate(function(options) {
   options = options || {};
 
   if (!this.topology) return false;
   return this.topology.isConnected(options);
-};
+}, 'isConnected is deprecated and will be removed in the next major version');
 
 /**
  * Connect to MongoDB using a url as documented at

package/lib/operations/connect.js

@@ -138,6 +138,7 @@ const validOptionNames = [
   'auto_reconnect',
   'minSize',
   'monitorCommands',
+  'serverApi',
   'retryWrites',
   'retryReads',
   'useNewUrlParser',

package/lib/operations/estimated_document_count.js

@@ -3,41 +3,69 @@
 const Aspect = require('./operation').Aspect;
 const defineAspects = require('./operation').defineAspects;
 const CommandOperationV2 = require('./command_v2');
+const maxWireVersion = require('../core/utils').maxWireVersion;
+const CountDocumentsOperation = require('./count_documents');
 
 class EstimatedDocumentCountOperation extends CommandOperationV2 {
-  constructor(collection, query, options) {
-    if (typeof options === 'undefined') {
-      options = query;
-      query = undefined;
-    }
-
+  constructor(collection, options) {
     super(collection, options);
+    this.collection = collection;
     this.collectionName = collection.s.namespace.collection;
-    if (query) {
-      this.query = query;
-    }
   }
 
   execute(server, callback) {
-    const options = this.options;
-    const cmd = { count: this.collectionName };
+    if (maxWireVersion(server) < 12) {
+      return this.executeLegacy(server, callback);
+    }
+    // if the user specifies a filter, use a CountDocumentsOperation instead
+    if (this.options.query) {
+      const op = new CountDocumentsOperation(this.collection, this.options.query, this.options);
+      return op.execute(server, callback);
+    }
+    const pipeline = [{ $collStats: { count: {} } }, { $group: { _id: 1, n: { $sum: '$count' } } }];
+    const cmd = { aggregate: this.collectionName, pipeline, cursor: {} };
 
-    if (this.query) {
-      cmd.query = this.query;
+    if (typeof this.options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = this.options.maxTimeMS;
     }
 
+    super.executeCommand(server, cmd, (err, response) => {
+      if (err && err.code !== 26) {
+        callback(err);
+        return;
+      }
+
+      callback(
+        undefined,
+        (response &&
+          response.cursor &&
+          response.cursor.firstBatch &&
+          response.cursor.firstBatch[0].n) ||
+          0
+      );
+    });
+  }
+
+  executeLegacy(server, callback) {
+    const cmd = { count: this.collectionName };
+
+    const options = this.options;
+    if (options.query) {
+      cmd.query = options.query;
+    }
+    if (options.hint) {
+      cmd.hint = options.hint;
+    }
+    if (typeof options.maxTimeMS === 'number') {
+      cmd.maxTimeMS = options.maxTimeMS;
+    }
     if (typeof options.skip === 'number') {
       cmd.skip = options.skip;
     }
-
     if (typeof options.limit === 'number') {
       cmd.limit = options.limit;
     }
 
-    if (options.hint) {
-      cmd.hint = options.hint;
-    }
-
     super.executeCommand(server, cmd, (err, response) => {
       if (err) {
         callback(err);

package/lib/topologies/native_topology.js

@@ -44,6 +44,8 @@ class NativeTopology extends Topology {
     // Translate all the options to the core types
     clonedOptions = translateOptions(clonedOptions, socketOptions);
 
+    clonedOptions.serverApi = options.serverApi;
+
     super(servers, clonedOptions);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.6.12",
+  "version": "3.7.0",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [
@@ -102,7 +102,7 @@
     "check:tls": "mocha --opts '{}' test/manual/tls_support.test.js",
     "format": "npm run check:lint -- --fix",
     "release": "standard-version -i HISTORY.md",
-    "test": "npm run lint && mocha --recursive test/functional test/unit"
+    "test": "npm run check:lint && mocha --recursive test/functional test/unit"
   },
   "homepage": "https://github.com/mongodb/node-mongodb-native",
   "optionalDependencies": {