mongodb 3.6.11 → 3.7.2

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',
@@ -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/auth/mongo_credentials.js

@@ -58,7 +58,10 @@ class MongoCredentials {
         this.password = process.env.AWS_SECRET_ACCESS_KEY;
       }
 
-      if (!this.mechanismProperties.AWS_SESSION_TOKEN && process.env.AWS_SESSION_TOKEN) {
+      if (
+        this.mechanismProperties.AWS_SESSION_TOKEN == null &&
+        process.env.AWS_SESSION_TOKEN != null
+      ) {
         this.mechanismProperties.AWS_SESSION_TOKEN = process.env.AWS_SESSION_TOKEN;
       }
     }

package/lib/core/auth/mongodb_aws.js

@@ -51,12 +51,21 @@ class MongoDBAWS extends AuthProvider {
       return;
     }
 
-    const username = credentials.username;
-    const password = credentials.password;
     const db = credentials.source;
-    const token = credentials.mechanismProperties.AWS_SESSION_TOKEN;
     const bson = this.bson;
 
+    const accessKeyId = credentials.username;
+    const secretAccessKey = credentials.password;
+    const sessionToken = credentials.mechanismProperties.AWS_SESSION_TOKEN;
+
+    // If all three defined, include sessionToken, else include username and pass, else no credentials
+    const awsCredentials =
+      accessKeyId && secretAccessKey && sessionToken
+        ? { accessKeyId, secretAccessKey, sessionToken }
+        : accessKeyId && secretAccessKey
+        ? { accessKeyId, secretAccessKey }
+        : undefined;
+
     crypto.randomBytes(32, (err, nonce) => {
       if (err) {
         callback(err);
@@ -109,18 +118,14 @@ class MongoDBAWS extends AuthProvider {
             path: '/',
             body
           },
-          {
-            accessKeyId: username,
-            secretAccessKey: password,
-            token
-          }
+          awsCredentials
         );
 
         const authorization = options.headers.Authorization;
         const date = options.headers['X-Amz-Date'];
         const payload = { a: authorization, d: date };
-        if (token) {
-          payload.t = token;
+        if (sessionToken) {
+          payload.t = sessionToken;
         }
 
         const saslContinue = {
@@ -164,6 +169,7 @@ function makeTempCredentials(credentials, callback) {
   if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
     request(
       `${AWS_RELATIVE_URI}${process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI}`,
+      undefined,
       (err, res) => {
         if (err) return callback(err);
         done(res);
@@ -215,11 +221,6 @@ function deriveRegion(host) {
 }
 
 function request(uri, options, callback) {
-  if (typeof options === 'function') {
-    callback = options;
-    options = {};
-  }
-
   options = Object.assign(
     {
       method: 'GET',

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';
@@ -190,6 +191,7 @@ class Connection extends EventEmitter {
    * Unref this connection
    * @method
    * @return {boolean}
+   * @deprecated This function is deprecated and will be removed in the next major version.
    */
   unref() {
     if (this.socket == null) {

package/lib/core/connection/pool.js

@@ -604,6 +604,7 @@ Pool.prototype.logout = function(dbName, callback) {
 /**
  * Unref the pool
  * @method
+ * @deprecated This function is deprecated and will be removed in the next major version.
  */
 Pool.prototype.unref = function() {
   // Get all the known connections

package/lib/core/connection/utils.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const parsePackageVersion = require('../../utils').parsePackageVersion;
+const MongoError = require('../error').MongoError;
+
 const require_optional = require('optional-require')(require);
 
 function debugOptions(debugFields, options) {
@@ -16,7 +19,15 @@ function retrieveBSON() {
   BSON.native = false;
 
   const optionalBSON = require_optional('bson-ext');
+  const bsonExtVersion = parsePackageVersion(
+    require_optional('bson-ext/package.json') || { version: '0.0.0' }
+  );
   if (optionalBSON) {
+    if (bsonExtVersion.major >= 4) {
+      throw new MongoError(
+        'bson-ext version 4 and above does not work with the 3.x version of the mongodb driver'
+      );
+    }
     optionalBSON.native = true;
     return optionalBSON;
   }
@@ -31,21 +42,43 @@ function noSnappyWarning() {
   );
 }
 
+const PKG_VERSION = Symbol('kPkgVersion');
+
 // Facilitate loading Snappy optionally
 function retrieveSnappy() {
-  let snappy = require_optional('snappy');
+  const snappy = require_optional('snappy');
   if (!snappy) {
-    snappy = {
+    return {
       compress: noSnappyWarning,
       uncompress: noSnappyWarning,
       compressSync: noSnappyWarning,
       uncompressSync: noSnappyWarning
     };
   }
+
+  const snappyPkg = require_optional('snappy/package.json') || { version: '0.0.0' };
+  const version = parsePackageVersion(snappyPkg);
+  snappy[PKG_VERSION] = version;
+  if (version.major >= 7) {
+    const compressOriginal = snappy.compress;
+    const uncompressOriginal = snappy.uncompress;
+    snappy.compress = (data, callback) => {
+      compressOriginal(data)
+        .then(res => callback(undefined, res))
+        .catch(error => callback(error));
+    };
+    snappy.uncompress = (data, callback) => {
+      uncompressOriginal(data)
+        .then(res => callback(undefined, res))
+        .catch(error => callback(error));
+    };
+  }
+
   return snappy;
 }
 
 module.exports = {
+  PKG_VERSION,
   debugOptions,
   retrieveBSON,
   retrieveSnappy

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();
@@ -742,8 +747,11 @@ class Topology extends EventEmitter {
     return this.s.state === STATE_CLOSED;
   }
 
+  /**
+   * @deprecated This function is deprecated and will be removed in the next major version.
+   */
   unref() {
-    emitWarning('not implemented: `unref`');
+    emitWarning('`unref` is a noop and will be removed in the next major version');
   }
 
   // NOTE: There are many places in code where we explicitly check the last isMaster

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