mongodb 3.6.11 → 3.7.2

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/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

@@ -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`')
@@ -432,6 +437,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);
@@ -593,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/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/db.js

@@ -951,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();

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/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

@@ -1,14 +1,12 @@
 'use strict';
 
-var core = require('../core');
-var crypto = require('crypto');
-var stream = require('stream');
-var util = require('util');
-var Buffer = require('safe-buffer').Buffer;
-
-var ERROR_NAMESPACE_NOT_FOUND = 26;
-
-module.exports = GridFSBucketWriteStream;
+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;
 
 /**
  * A writable stream that enables you to write buffers to GridFS.
@@ -31,42 +29,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);
 
@@ -210,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) {
@@ -309,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) {
@@ -539,3 +544,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