mongodb 3.6.12 → 3.7.3

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/bulk/common.js

@@ -414,6 +414,15 @@ class WriteError {
   }
 }
 
+/**
+ * Converts the number to a Long or returns it.
+ *
+ * @ignore
+ */
+function longOrConvert(value) {
+  return typeof value === 'number' ? Long.fromNumber(value) : value;
+}
+
 /**
  * Merges results into shared data structure
  * @ignore
@@ -445,42 +454,37 @@ function mergeBatchResults(batch, bulkResult, err, result) {
     return;
   }
 
-  // Deal with opTime if available
+  // The server write command specification states that lastOp is an optional
+  // mongod only field that has a type of timestamp. Across various scarce specs
+  // where opTime is mentioned, it is an "opaque" object that can have a "ts" and
+  // "t" field with Timestamp and Long as their types respectively.
+  // The "lastOp" field of the bulk write result is never mentioned in the driver
+  // specifications or the bulk write spec, so we should probably just keep its
+  // value consistent since it seems to vary.
+  // See: https://github.com/mongodb/specifications/blob/master/source/driver-bulk-update.rst#results-object
   if (result.opTime || result.lastOp) {
-    const opTime = result.lastOp || result.opTime;
-    let lastOpTS = null;
-    let lastOpT = null;
+    let opTime = result.lastOp || result.opTime;
 
-    // We have a time stamp
-    if (opTime && opTime._bsontype === 'Timestamp') {
-      if (bulkResult.lastOp == null) {
-        bulkResult.lastOp = opTime;
-      } else if (opTime.greaterThan(bulkResult.lastOp)) {
-        bulkResult.lastOp = opTime;
-      }
-    } else {
-      // Existing TS
-      if (bulkResult.lastOp) {
-        lastOpTS =
-          typeof bulkResult.lastOp.ts === 'number'
-            ? Long.fromNumber(bulkResult.lastOp.ts)
-            : bulkResult.lastOp.ts;
-        lastOpT =
-          typeof bulkResult.lastOp.t === 'number'
-            ? Long.fromNumber(bulkResult.lastOp.t)
-            : bulkResult.lastOp.t;
-      }
-
-      // Current OpTime TS
-      const opTimeTS = typeof opTime.ts === 'number' ? Long.fromNumber(opTime.ts) : opTime.ts;
-      const opTimeT = typeof opTime.t === 'number' ? Long.fromNumber(opTime.t) : opTime.t;
+    // If the opTime is a Timestamp, convert it to a consistent format to be
+    // able to compare easily. Converting to the object from a timestamp is
+    // much more straightforward than the other direction.
+    if (opTime._bsontype === 'Timestamp') {
+      opTime = { ts: opTime, t: Long.ZERO };
+    }
 
-      // Compare the opTime's
-      if (bulkResult.lastOp == null) {
-        bulkResult.lastOp = opTime;
-      } else if (opTimeTS.greaterThan(lastOpTS)) {
+    // If there's no lastOp, just set it.
+    if (!bulkResult.lastOp) {
+      bulkResult.lastOp = opTime;
+    } else {
+      // First compare the ts values and set if the opTimeTS value is greater.
+      const lastOpTS = longOrConvert(bulkResult.lastOp.ts);
+      const opTimeTS = longOrConvert(opTime.ts);
+      if (opTimeTS.greaterThan(lastOpTS)) {
         bulkResult.lastOp = opTime;
       } else if (opTimeTS.equals(lastOpTS)) {
+        // If the ts values are equal, then compare using the t values.
+        const lastOpT = longOrConvert(bulkResult.lastOp.t);
+        const opTimeT = longOrConvert(opTime.t);
         if (opTimeT.greaterThan(lastOpT)) {
           bulkResult.lastOp = opTime;
         }
@@ -1387,6 +1391,7 @@ Object.defineProperty(BulkOperationBase.prototype, 'length', {
 module.exports = {
   Batch,
   BulkOperationBase,
+  mergeBatchResults,
   bson,
   INSERT: INSERT,
   UPDATE: UPDATE,

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

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

@@ -95,6 +95,8 @@ function performInitialHandshake(conn, options, _callback) {
       handshakeOptions.socketTimeout = options.connectTimeoutMS || options.connectionTimeout;
     }
 
+    handshakeDoc.helloOk = !!options.useUnifiedTopology;
+
     const start = new Date().getTime();
     conn.command('admin.$cmd', handshakeDoc, handshakeOptions, (err, result) => {
       if (err) {
@@ -108,6 +110,15 @@ function performInitialHandshake(conn, options, _callback) {
         return;
       }
 
+      if ('isWritablePrimary' in response) {
+        // Provide pre-hello-style response document.
+        response.ismaster = response.isWritablePrimary;
+      }
+
+      if (options.useUnifiedTopology && response.helloOk) {
+        conn.helloOk = true;
+      }
+
       const supportedServerErr = checkSupportedServer(response, options);
       if (supportedServerErr) {
         callback(supportedServerErr);
@@ -158,11 +169,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
   };
@@ -266,12 +278,17 @@ function makeConnection(family, options, cancellationToken, _callback) {
       : typeof options.connectTimeoutMS === 'number'
       ? options.connectTimeoutMS
       : 30000;
-  const socketTimeout = typeof options.socketTimeout === 'number' ? options.socketTimeout : 0;
+  const socketTimeoutMS =
+    typeof options.socketTimeoutMS === 'number'
+      ? options.socketTimeoutMS
+      : typeof options.socketTimeout === 'number'
+      ? options.socketTimeout
+      : 0;
   const rejectUnauthorized =
     typeof options.rejectUnauthorized === 'boolean' ? options.rejectUnauthorized : true;
 
-  if (keepAliveInitialDelay > socketTimeout) {
-    keepAliveInitialDelay = Math.round(socketTimeout / 2);
+  if (keepAliveInitialDelay > socketTimeoutMS) {
+    keepAliveInitialDelay = Math.round(socketTimeoutMS / 2);
   }
 
   let socket;
@@ -324,7 +341,7 @@ function makeConnection(family, options, cancellationToken, _callback) {
       return callback(socket.authorizationError);
     }
 
-    socket.setTimeout(socketTimeout);
+    socket.setTimeout(socketTimeoutMS);
     callback(null, socket);
   }
 

package/lib/core/connection/connection.js

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

package/lib/core/error.js

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

package/lib/core/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

@@ -65,7 +65,8 @@ class Monitor extends EventEmitter {
       heartbeatFrequencyMS:
         typeof options.heartbeatFrequencyMS === 'number' ? options.heartbeatFrequencyMS : 10000,
       minHeartbeatFrequencyMS:
-        typeof options.minHeartbeatFrequencyMS === 'number' ? options.minHeartbeatFrequencyMS : 500
+        typeof options.minHeartbeatFrequencyMS === 'number' ? options.minHeartbeatFrequencyMS : 500,
+      useUnifiedTopology: options.useUnifiedTopology
     });
 
     // TODO: refactor this to pull it directly from the pool, requires new ConnectionPool integration
@@ -204,8 +205,16 @@ 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 helloOk = monitor[kConnection].helloOk;
+
+    const cmd = {
+      [serverApi || helloOk ? 'hello' : 'ismaster']: true
+    };
+
+    // written this way omit helloOk from the command if its false-y (do not want -> helloOk: null)
+    if (helloOk) cmd.helloOk = helloOk;
 
-    const cmd = { ismaster: true };
     const options = { socketTimeout: connectTimeoutMS };
 
     if (isAwaitable) {
@@ -229,6 +238,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/server_description.js

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

package/lib/core/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/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;