mongodb 3.5.7 → 3.5.8

package/HISTORY.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+<a name="3.5.8"></a>
+## [3.5.8](https://github.com/mongodb/node-mongodb-native/compare/v3.5.7...v3.5.8) (2020-05-28)
+
+
+### Bug Fixes
+
+* always clear cancelled wait queue members during processing ([0394f9d](https://github.com/mongodb/node-mongodb-native/commit/0394f9d))
+* always include `writeErrors` on a `BulkWriteError` instance ([58b4f94](https://github.com/mongodb/node-mongodb-native/commit/58b4f94))
+* ensure implicit sessions are ended consistently ([5c6fda1](https://github.com/mongodb/node-mongodb-native/commit/5c6fda1))
+* filter servers before applying reducers ([4faf9f5](https://github.com/mongodb/node-mongodb-native/commit/4faf9f5))
+* unordered bulk write should attempt to execute all batches ([6cee96b](https://github.com/mongodb/node-mongodb-native/commit/6cee96b))
+* **ChangeStream:** should resume from errors when iterating ([5ecf18e](https://github.com/mongodb/node-mongodb-native/commit/5ecf18e))
+* honor journal=true in connection string ([#2359](https://github.com/mongodb/node-mongodb-native/issues/2359)) ([246669f](https://github.com/mongodb/node-mongodb-native/commit/246669f))
+* **ChangeStream:** whitelist resumable errors ([#2337](https://github.com/mongodb/node-mongodb-native/issues/2337)) ([a9d3965](https://github.com/mongodb/node-mongodb-native/commit/a9d3965)), closes [#17](https://github.com/mongodb/node-mongodb-native/issues/17) [#18](https://github.com/mongodb/node-mongodb-native/issues/18)
+
+
+
 <a name="3.5.7"></a>
 ## [3.5.7](https://github.com/mongodb/node-mongodb-native/compare/v3.5.6...v3.5.7) (2020-04-29)
 

package/lib/bulk/common.js

@@ -1200,19 +1200,10 @@ class BulkOperationBase {
    * @ignore
    * @param {function} callback
    * @param {BulkWriteResult} writeResult
-   * @param {class} self either OrderedBulkOperation or UnorderdBulkOperation
+   * @param {class} self either OrderedBulkOperation or UnorderedBulkOperation
    */
   handleWriteError(callback, writeResult) {
     if (this.s.bulkResult.writeErrors.length > 0) {
-      if (this.s.bulkResult.writeErrors.length === 1) {
-        handleCallback(
-          callback,
-          new BulkWriteError(toError(this.s.bulkResult.writeErrors[0]), writeResult),
-          null
-        );
-        return true;
-      }
-
       const msg = this.s.bulkResult.writeErrors[0].errmsg
         ? this.s.bulkResult.writeErrors[0].errmsg
         : 'write operation failed';
@@ -1230,7 +1221,9 @@ class BulkOperationBase {
         null
       );
       return true;
-    } else if (writeResult.getWriteConcernError()) {
+    }
+
+    if (writeResult.getWriteConcernError()) {
       handleCallback(
         callback,
         new BulkWriteError(toError(writeResult.getWriteConcernError()), writeResult),

package/lib/bulk/unordered.js

@@ -108,6 +108,14 @@ class UnorderedBulkOperation extends BulkOperationBase {
 
     super(topology, collection, options, false);
   }
+
+  handleWriteError(callback, writeResult) {
+    if (this.s.batches.length) {
+      return false;
+    }
+
+    return super.handleWriteError(callback, writeResult);
+  }
 }
 
 /**

package/lib/change_stream.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const Denque = require('denque');
 const EventEmitter = require('events');
 const isResumableError = require('./error').isResumableError;
 const MongoError = require('./core').MongoError;
@@ -9,6 +10,8 @@ const maxWireVersion = require('./core/utils').maxWireVersion;
 const maybePromise = require('./utils').maybePromise;
 const AggregateOperation = require('./operations/aggregate');
 
+const kResumeQueue = Symbol('resumeQueue');
+
 const CHANGE_STREAM_OPTIONS = ['resumeAfter', 'startAfter', 'startAtOperationTime', 'fullDocument'];
 const CURSOR_OPTIONS = ['batchSize', 'maxAwaitTimeMS', 'collation', 'readPreference'].concat(
   CHANGE_STREAM_OPTIONS
@@ -91,15 +94,17 @@ class ChangeStream extends EventEmitter {
       this.options.readPreference = parent.s.readPreference;
     }
 
+    this[kResumeQueue] = new Denque();
+
     // Create contained Change Stream cursor
     this.cursor = createChangeStreamCursor(this, options);
 
+    this.closed = false;
+
     // Listen for any `change` listeners being added to ChangeStream
     this.on('newListener', eventName => {
       if (eventName === 'change' && this.cursor && this.listenerCount('change') === 0) {
-        this.cursor.on('data', change =>
-          processNewChange({ changeStream: this, change, eventEmitter: true })
-        );
+        this.cursor.on('data', change => processNewChange(this, change));
       }
     });
 
@@ -128,7 +133,12 @@ class ChangeStream extends EventEmitter {
    * @returns {Promise|void} returns Promise if no callback passed
    */
   hasNext(callback) {
-    return maybePromise(this.parent, callback, cb => this.cursor.hasNext(cb));
+    return maybePromise(this.parent, callback, cb => {
+      getCursor(this, (err, cursor) => {
+        if (err) return cb(err); // failed to resume, raise an error
+        cursor.hasNext(cb);
+      });
+    });
   }
 
   /**
@@ -140,25 +150,28 @@ class ChangeStream extends EventEmitter {
    */
   next(callback) {
     return maybePromise(this.parent, callback, cb => {
-      if (this.isClosed()) {
-        return cb(new Error('Change Stream is not open.'));
-      }
-      this.cursor.next((error, change) => {
-        processNewChange({ changeStream: this, error, change, callback: cb });
+      getCursor(this, (err, cursor) => {
+        if (err) return cb(err); // failed to resume, raise an error
+        cursor.next((error, change) => {
+          if (error) {
+            this[kResumeQueue].push(() => this.next(cb));
+            processError(this, error, cb);
+            return;
+          }
+          processNewChange(this, change, cb);
+        });
       });
     });
   }
 
   /**
-   * Is the cursor closed
+   * Is the change stream closed
    * @method ChangeStream.prototype.isClosed
+   * @param  {boolean} [checkCursor=true] also check if the underlying cursor is closed
    * @return {boolean}
    */
   isClosed() {
-    if (this.cursor) {
-      return this.cursor.isClosed();
-    }
-    return true;
+    return this.closed || (this.cursor && this.cursor.isClosed());
   }
 
   /**
@@ -168,31 +181,22 @@ class ChangeStream extends EventEmitter {
    * @return {Promise} returns Promise if no callback passed
    */
   close(callback) {
-    if (!this.cursor) {
-      if (callback) return callback();
-      return this.promiseLibrary.resolve();
-    }
+    return maybePromise(this.parent, callback, cb => {
+      if (this.closed) return cb();
 
-    // Tidy up the existing cursor
-    const cursor = this.cursor;
+      // flag the change stream as explicitly closed
+      this.closed = true;
 
-    if (callback) {
-      return cursor.close(err => {
-        ['data', 'close', 'end', 'error'].forEach(event => cursor.removeAllListeners(event));
-        delete this.cursor;
+      if (!this.cursor) return cb();
 
-        return callback(err);
-      });
-    }
+      // Tidy up the existing cursor
+      const cursor = this.cursor;
 
-    const PromiseCtor = this.promiseLibrary || Promise;
-    return new PromiseCtor((resolve, reject) => {
-      cursor.close(err => {
+      return cursor.close(err => {
         ['data', 'close', 'end', 'error'].forEach(event => cursor.removeAllListeners(event));
-        delete this.cursor;
+        this.cursor = undefined;
 
-        if (err) return reject(err);
-        resolve();
+        return cb(err);
       });
     });
   }
@@ -287,7 +291,9 @@ class ChangeStreamCursor extends Cursor {
       ['resumeAfter', 'startAfter', 'startAtOperationTime'].forEach(key => delete result[key]);
 
       if (this.resumeToken) {
-        result.resumeAfter = this.resumeToken;
+        const resumeKey =
+          this.options.startAfter && !this.hasReceived ? 'startAfter' : 'resumeAfter';
+        result[resumeKey] = this.resumeToken;
       } else if (this.startAtOperationTime && maxWireVersion(this.server) >= 7) {
         result.startAtOperationTime = this.startAtOperationTime;
       }
@@ -296,10 +302,30 @@ class ChangeStreamCursor extends Cursor {
     return result;
   }
 
+  cacheResumeToken(resumeToken) {
+    if (this.bufferedCount() === 0 && this.cursorState.postBatchResumeToken) {
+      this.resumeToken = this.cursorState.postBatchResumeToken;
+    } else {
+      this.resumeToken = resumeToken;
+    }
+    this.hasReceived = true;
+  }
+
+  _processBatch(batchName, response) {
+    const cursor = response.cursor;
+    if (cursor.postBatchResumeToken) {
+      this.cursorState.postBatchResumeToken = cursor.postBatchResumeToken;
+
+      if (cursor[batchName].length === 0) {
+        this.resumeToken = cursor.postBatchResumeToken;
+      }
+    }
+  }
+
   _initializeCursor(callback) {
     super._initializeCursor((err, result) => {
       if (err) {
-        callback(err, null);
+        callback(err);
         return;
       }
 
@@ -314,15 +340,9 @@ class ChangeStreamCursor extends Cursor {
         this.startAtOperationTime = response.operationTime;
       }
 
-      const cursor = response.cursor;
-      if (cursor.postBatchResumeToken) {
-        this.cursorState.postBatchResumeToken = cursor.postBatchResumeToken;
-
-        if (cursor.firstBatch.length === 0) {
-          this.resumeToken = cursor.postBatchResumeToken;
-        }
-      }
+      this._processBatch('firstBatch', response);
 
+      this.emit('init', result);
       this.emit('response');
       callback(err, result);
     });
@@ -331,19 +351,13 @@ class ChangeStreamCursor extends Cursor {
   _getMore(callback) {
     super._getMore((err, response) => {
       if (err) {
-        callback(err, null);
+        callback(err);
         return;
       }
 
-      const cursor = response.cursor;
-      if (cursor.postBatchResumeToken) {
-        this.cursorState.postBatchResumeToken = cursor.postBatchResumeToken;
-
-        if (cursor.nextBatch.length === 0) {
-          this.resumeToken = cursor.postBatchResumeToken;
-        }
-      }
+      this._processBatch('nextBatch', response);
 
+      this.emit('more', response);
       this.emit('response');
       callback(err, response);
     });
@@ -366,6 +380,7 @@ function createChangeStreamCursor(self, options) {
 
   const pipeline = [{ $changeStream: changeStreamStageOptions }].concat(self.pipeline);
   const cursorOptions = applyKnownOptions({}, options, CURSOR_OPTIONS);
+
   const changeStreamCursor = new ChangeStreamCursor(
     self.topology,
     new AggregateOperation(self.parent, pipeline, options),
@@ -384,7 +399,7 @@ function createChangeStreamCursor(self, options) {
    */
   if (self.listenerCount('change') > 0) {
     changeStreamCursor.on('data', function(change) {
-      processNewChange({ changeStream: self, change, eventEmitter: true });
+      processNewChange(self, change);
     });
   }
 
@@ -416,7 +431,7 @@ function createChangeStreamCursor(self, options) {
    * @type {Error}
    */
   changeStreamCursor.on('error', function(error) {
-    processNewChange({ changeStream: self, error, eventEmitter: true });
+    processError(self, error);
   });
 
   if (self.pipeDestinations) {
@@ -449,120 +464,141 @@ function waitForTopologyConnected(topology, options, callback) {
     const timeout = options.timeout || SELECTION_TIMEOUT;
     const readPreference = options.readPreference;
 
-    if (topology.isConnected({ readPreference })) return callback(null, null);
+    if (topology.isConnected({ readPreference })) return callback();
     const hrElapsed = process.hrtime(start);
     const elapsed = (hrElapsed[0] * 1e9 + hrElapsed[1]) / 1e6;
     if (elapsed > timeout) return callback(new MongoError('Timed out waiting for connection'));
     waitForTopologyConnected(topology, options, callback);
-  }, 3000); // this is an arbitrary wait time to allow SDAM to transition
+  }, 500); // this is an arbitrary wait time to allow SDAM to transition
 }
 
-// Handle new change events. This method brings together the routes from the callback, event emitter, and promise ways of using ChangeStream.
-function processNewChange(args) {
-  const changeStream = args.changeStream;
-  const error = args.error;
-  const change = args.change;
-  const callback = args.callback;
-  const eventEmitter = args.eventEmitter || false;
+function processNewChange(changeStream, change, callback) {
+  const cursor = changeStream.cursor;
 
-  // If the changeStream is closed, then it should not process a change.
-  if (changeStream.isClosed()) {
-    // We do not error in the eventEmitter case.
-    if (eventEmitter) {
-      return;
-    }
+  if (changeStream.closed) {
+    if (callback) callback(new MongoError('ChangeStream is closed'));
+    return;
+  }
 
-    const error = new MongoError('ChangeStream is closed');
-    return typeof callback === 'function'
-      ? callback(error, null)
-      : changeStream.promiseLibrary.reject(error);
+  if (change && !change._id) {
+    const noResumeTokenError = new Error(
+      'A change stream document has been received that lacks a resume token (_id).'
+    );
+
+    if (!callback) return changeStream.emit('error', noResumeTokenError);
+    return callback(noResumeTokenError);
   }
 
-  const cursor = changeStream.cursor;
+  // cache the resume token
+  cursor.cacheResumeToken(change._id);
+
+  // wipe the startAtOperationTime if there was one so that there won't be a conflict
+  // between resumeToken and startAtOperationTime if we need to reconnect the cursor
+  changeStream.options.startAtOperationTime = undefined;
+
+  // Return the change
+  if (!callback) return changeStream.emit('change', change);
+  return callback(undefined, change);
+}
+
+function processError(changeStream, error, callback) {
   const topology = changeStream.topology;
-  const options = changeStream.cursor.options;
+  const cursor = changeStream.cursor;
 
-  if (error) {
-    if (isResumableError(error) && !changeStream.attemptingResume) {
-      changeStream.attemptingResume = true;
+  // If the change stream has been closed explictly, do not process error.
+  if (changeStream.closed) {
+    if (callback) callback(new MongoError('ChangeStream is closed'));
+    return;
+  }
 
-      // stop listening to all events from old cursor
-      ['data', 'close', 'end', 'error'].forEach(event =>
-        changeStream.cursor.removeAllListeners(event)
-      );
+  // if the resume succeeds, continue with the new cursor
+  function resumeWithCursor(newCursor) {
+    changeStream.cursor = newCursor;
+    processResumeQueue(changeStream);
+  }
 
-      // close internal cursor, ignore errors
-      changeStream.cursor.close();
+  // otherwise, raise an error and close the change stream
+  function unresumableError(err) {
+    if (!callback) {
+      changeStream.emit('error', err);
+      changeStream.emit('close');
+    }
+    processResumeQueue(changeStream, err);
+    changeStream.closed = true;
+  }
 
-      // attempt recreating the cursor
-      if (eventEmitter) {
-        waitForTopologyConnected(topology, { readPreference: options.readPreference }, err => {
-          if (err) {
-            changeStream.emit('error', err);
-            changeStream.emit('close');
-            return;
-          }
-          changeStream.cursor = createChangeStreamCursor(changeStream, cursor.resumeOptions);
-        });
+  if (cursor && isResumableError(error, maxWireVersion(cursor.server))) {
+    changeStream.cursor = undefined;
 
-        return;
-      }
+    // stop listening to all events from old cursor
+    ['data', 'close', 'end', 'error'].forEach(event => cursor.removeAllListeners(event));
 
-      if (callback) {
-        waitForTopologyConnected(topology, { readPreference: options.readPreference }, err => {
-          if (err) return callback(err, null);
+    // close internal cursor, ignore errors
+    cursor.close();
 
-          changeStream.cursor = createChangeStreamCursor(changeStream, cursor.resumeOptions);
-          changeStream.next(callback);
-        });
+    waitForTopologyConnected(topology, { readPreference: cursor.options.readPreference }, err => {
+      // if the topology can't reconnect, close the stream
+      if (err) return unresumableError(err);
 
-        return;
-      }
+      // create a new cursor, preserving the old cursor's options
+      const newCursor = createChangeStreamCursor(changeStream, cursor.resumeOptions);
 
-      return new Promise((resolve, reject) => {
-        waitForTopologyConnected(topology, { readPreference: options.readPreference }, err => {
-          if (err) return reject(err);
-          resolve();
-        });
-      })
-        .then(
-          () => (changeStream.cursor = createChangeStreamCursor(changeStream, cursor.resumeOptions))
-        )
-        .then(() => changeStream.next());
-    }
+      // attempt to continue in emitter mode
+      if (!callback) return resumeWithCursor(newCursor);
 
-    if (eventEmitter) return changeStream.emit('error', error);
-    if (typeof callback === 'function') return callback(error, null);
-    return changeStream.promiseLibrary.reject(error);
+      // attempt to continue in iterator mode
+      newCursor.hasNext(err => {
+        // if there's an error immediately after resuming, close the stream
+        if (err) return unresumableError(err);
+        resumeWithCursor(newCursor);
+      });
+    });
+    return;
   }
 
-  changeStream.attemptingResume = false;
-
-  if (change && !change._id) {
-    const noResumeTokenError = new Error(
-      'A change stream document has been received that lacks a resume token (_id).'
-    );
+  if (!callback) return changeStream.emit('error', error);
+  return callback(error);
+}
 
-    if (eventEmitter) return changeStream.emit('error', noResumeTokenError);
-    if (typeof callback === 'function') return callback(noResumeTokenError, null);
-    return changeStream.promiseLibrary.reject(noResumeTokenError);
+/**
+ * Safely provides a cursor across resume attempts
+ *
+ * @param {ChangeStream} changeStream the parent ChangeStream
+ * @param {function} callback gets the cursor or error
+ * @param {ChangeStreamCursor} [oldCursor] when resuming from an error, carry over options from previous cursor
+ */
+function getCursor(changeStream, callback) {
+  if (changeStream.isClosed()) {
+    callback(new MongoError('ChangeStream is closed.'));
+    return;
   }
 
-  // cache the resume token
-  if (cursor.bufferedCount() === 0 && cursor.cursorState.postBatchResumeToken) {
-    cursor.resumeToken = cursor.cursorState.postBatchResumeToken;
-  } else {
-    cursor.resumeToken = change._id;
+  // if a cursor exists and it is open, return it
+  if (changeStream.cursor) {
+    callback(undefined, changeStream.cursor);
+    return;
   }
 
-  // wipe the startAtOperationTime if there was one so that there won't be a conflict
-  // between resumeToken and startAtOperationTime if we need to reconnect the cursor
-  changeStream.options.startAtOperationTime = undefined;
+  // no cursor, queue callback until topology reconnects
+  changeStream[kResumeQueue].push(callback);
+}
 
-  // Return the change
-  if (eventEmitter) return changeStream.emit('change', change);
-  if (typeof callback === 'function') return callback(error, change);
-  return changeStream.promiseLibrary.resolve(change);
+/**
+ * Drain the resume queue when a new has become available
+ *
+ * @param {ChangeStream} changeStream the parent ChangeStream
+ * @param {ChangeStreamCursor?} changeStream.cursor the new cursor
+ * @param {Error} [err] error getting a new cursor
+ */
+function processResumeQueue(changeStream, err) {
+  while (changeStream[kResumeQueue].length) {
+    const request = changeStream[kResumeQueue].pop();
+    if (changeStream.isClosed() && !err) {
+      request(new MongoError('Change Stream is not open.'));
+      return;
+    }
+    request(err, changeStream.cursor);
+  }
 }
 
 /**

package/lib/cmap/connection_pool.js

@@ -198,6 +198,10 @@ class ConnectionPool extends EventEmitter {
     return this[kConnections].length;
   }
 
+  get waitQueueSize() {
+    return this[kWaitQueue].length;
+  }
+
   /**
    * Check a connection out of this pool. The connection will continue to be tracked, but no reference to it
    * will be held by the pool. This means that if a connection is checked out it MUST be checked back in or
@@ -295,7 +299,7 @@ class ConnectionPool extends EventEmitter {
     this[kCancellationToken].emit('cancel');
 
     // drain the wait queue
-    while (this[kWaitQueue].length) {
+    while (this.waitQueueSize) {
       const waitQueueMember = this[kWaitQueue].pop();
       clearTimeout(waitQueueMember.timer);
       if (!waitQueueMember[kCancelled]) {
@@ -449,13 +453,17 @@ function processWaitQueue(pool) {
     return;
   }
 
-  while (pool[kWaitQueue].length && pool.availableConnectionCount) {
+  while (pool.waitQueueSize) {
     const waitQueueMember = pool[kWaitQueue].peekFront();
     if (waitQueueMember[kCancelled]) {
       pool[kWaitQueue].shift();
       continue;
     }
 
+    if (!pool.availableConnectionCount) {
+      break;
+    }
+
     const connection = pool[kConnections].shift();
     const isStale = connectionIsStale(pool, connection);
     const isIdle = connectionIsIdle(pool, connection);
@@ -472,7 +480,7 @@ function processWaitQueue(pool) {
   }
 
   const maxPoolSize = pool.options.maxPoolSize;
-  if (pool[kWaitQueue].length && (maxPoolSize <= 0 || pool.totalConnectionCount < maxPoolSize)) {
+  if (pool.waitQueueSize && (maxPoolSize <= 0 || pool.totalConnectionCount < maxPoolSize)) {
     createConnection(pool, (err, connection) => {
       const waitQueueMember = pool[kWaitQueue].shift();
       if (waitQueueMember == null) {

package/lib/core/cursor.js

@@ -4,7 +4,6 @@ const Logger = require('./connection/logger');
 const retrieveBSON = require('./connection/utils').retrieveBSON;
 const MongoError = require('./error').MongoError;
 const MongoNetworkError = require('./error').MongoNetworkError;
-const mongoErrorContextSymbol = require('./error').mongoErrorContextSymbol;
 const collationNotSupported = require('./utils').collationNotSupported;
 const ReadPreference = require('./topologies/read_preference');
 const isUnifiedTopology = require('./utils').isUnifiedTopology;
@@ -412,7 +411,15 @@ class CoreCursor extends Readable {
       batchSize = this.cursorState.limit - this.cursorState.currentLimit;
     }
 
-    this.server.getMore(this.ns, this.cursorState, batchSize, this.options, callback);
+    const cursorState = this.cursorState;
+    this.server.getMore(this.ns, cursorState, batchSize, this.options, (err, result, conn) => {
+      // NOTE: `getMore` modifies `cursorState`, would be very ideal not to do so in the future
+      if (err || (cursorState.cursorId && cursorState.cursorId.isZero())) {
+        this._endSession();
+      }
+
+      callback(err, result, conn);
+    });
   }
 
   _initializeCursor(callback) {
@@ -433,18 +440,15 @@ class CoreCursor extends Readable {
     }
 
     function done(err, result) {
-      if (
-        cursor.cursorState.cursorId &&
-        cursor.cursorState.cursorId.isZero() &&
-        cursor._endSession
-      ) {
+      const cursorState = cursor.cursorState;
+      if (err || (cursorState.cursorId && cursorState.cursorId.isZero())) {
         cursor._endSession();
       }
 
       if (
-        cursor.cursorState.documents.length === 0 &&
-        cursor.cursorState.cursorId &&
-        cursor.cursorState.cursorId.isZero() &&
+        cursorState.documents.length === 0 &&
+        cursorState.cursorId &&
+        cursorState.cursorId.isZero() &&
         !cursor.cmd.tailable &&
         !cursor.cmd.awaitData
       ) {
@@ -690,8 +694,8 @@ function _setCursorNotifiedImpl(self, callback) {
   self.cursorState.documents = [];
   self.cursorState.cursorIndex = 0;
 
-  if (self._endSession) {
-    self._endSession(undefined, () => callback());
+  if (self.cursorState.session) {
+    self._endSession(callback);
     return;
   }
 
@@ -774,17 +778,9 @@ function nextFunction(self, callback) {
     // Execute the next get more
     self._getMore(function(err, doc, connection) {
       if (err) {
-        if (err instanceof MongoError) {
-          err[mongoErrorContextSymbol].isGetMore = true;
-        }
-
         return handleCallback(callback, err);
       }
 
-      if (self.cursorState.cursorId && self.cursorState.cursorId.isZero() && self._endSession) {
-        self._endSession();
-      }
-
       // Save the returned connection to ensure all getMore's fire over the same connection
       self.connection = connection;
 

package/lib/core/error.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
-
 /**
  * Creates a new MongoError
  *
@@ -21,6 +19,10 @@ class MongoError extends Error {
       } else {
         super(message.message || message.errmsg || message.$err || 'n/a');
         for (var name in message) {
+          if (name === 'errmsg') {
+            continue;
+          }
+
           this[name] = message[name];
         }
       }
@@ -29,7 +31,13 @@ class MongoError extends Error {
     }
 
     this.name = 'MongoError';
-    this[mongoErrorContextSymbol] = this[mongoErrorContextSymbol] || {};
+  }
+
+  /**
+   * Legacy name for server error responses
+   */
+  get errmsg() {
+    return this.message;
   }
 
   /**
@@ -262,7 +270,6 @@ module.exports = {
   MongoTimeoutError,
   MongoServerSelectionError,
   MongoWriteConcernError,
-  mongoErrorContextSymbol,
   isRetryableError,
   isSDAMUnrecoverableError,
   isNodeShuttingDownError,

package/lib/core/index.js

@@ -22,7 +22,6 @@ module.exports = {
   MongoTimeoutError: require('./error').MongoTimeoutError,
   MongoServerSelectionError: require('./error').MongoServerSelectionError,
   MongoWriteConcernError: require('./error').MongoWriteConcernError,
-  mongoErrorContextSymbol: require('./error').mongoErrorContextSymbol,
   // Core
   Connection: require('./connection/connection'),
   Server: require('./topologies/server'),

package/lib/core/sdam/server_selection.js

@@ -48,7 +48,7 @@ function maxStalenessReducer(readPreference, topologyDescription, servers) {
   }
 
   if (topologyDescription.type === TopologyType.ReplicaSetWithPrimary) {
-    const primary = servers.filter(primaryFilter)[0];
+    const primary = Array.from(topologyDescription.servers.values()).filter(primaryFilter)[0];
     return servers.reduce((result, server) => {
       const stalenessMS =
         server.lastUpdateTime -
@@ -197,50 +197,32 @@ function readPreferenceServerSelector(readPreference) {
       return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
     }
 
-    if (readPreference.mode === ReadPreference.PRIMARY) {
+    const mode = readPreference.mode;
+    if (mode === ReadPreference.PRIMARY) {
       return servers.filter(primaryFilter);
     }
 
-    if (readPreference.mode === ReadPreference.SECONDARY) {
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
-    } else if (readPreference.mode === ReadPreference.NEAREST) {
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(nearestFilter);
-    } else if (readPreference.mode === ReadPreference.SECONDARY_PREFERRED) {
-      const result = latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
-
-      return result.length === 0 ? servers.filter(primaryFilter) : result;
-    } else if (readPreference.mode === ReadPreference.PRIMARY_PREFERRED) {
+    if (mode === ReadPreference.PRIMARY_PREFERRED) {
       const result = servers.filter(primaryFilter);
       if (result.length) {
         return result;
       }
+    }
+
+    const filter = mode === ReadPreference.NEAREST ? nearestFilter : secondaryFilter;
+    const selectedServers = latencyWindowReducer(
+      topologyDescription,
+      tagSetReducer(
+        readPreference,
+        maxStalenessReducer(readPreference, topologyDescription, servers.filter(filter))
+      )
+    );
 
-      return latencyWindowReducer(
-        topologyDescription,
-        tagSetReducer(
-          readPreference,
-          maxStalenessReducer(readPreference, topologyDescription, servers)
-        )
-      ).filter(secondaryFilter);
+    if (mode === ReadPreference.SECONDARY_PREFERRED && selectedServers.length === 0) {
+      return servers.filter(primaryFilter);
     }
+
+    return selectedServers;
   };
 }
 

package/lib/core/utils.js

@@ -83,22 +83,24 @@ function retrieveEJSON() {
  * @param {(Topology|Server)} topologyOrServer
  */
 function maxWireVersion(topologyOrServer) {
-  if (topologyOrServer.ismaster) {
-    return topologyOrServer.ismaster.maxWireVersion;
-  }
+  if (topologyOrServer) {
+    if (topologyOrServer.ismaster) {
+      return topologyOrServer.ismaster.maxWireVersion;
+    }
 
-  if (typeof topologyOrServer.lastIsMaster === 'function') {
-    const lastIsMaster = topologyOrServer.lastIsMaster();
-    if (lastIsMaster) {
-      return lastIsMaster.maxWireVersion;
+    if (typeof topologyOrServer.lastIsMaster === 'function') {
+      const lastIsMaster = topologyOrServer.lastIsMaster();
+      if (lastIsMaster) {
+        return lastIsMaster.maxWireVersion;
+      }
     }
-  }
 
-  if (topologyOrServer.description) {
-    return topologyOrServer.description.maxWireVersion;
+    if (topologyOrServer.description) {
+      return topologyOrServer.description.maxWireVersion;
+    }
   }
 
-  return null;
+  return 0;
 }
 
 /*

package/lib/cursor.js

@@ -832,9 +832,7 @@ class Cursor extends CoreCursor {
       const fetchDocs = () => {
         cursor._next((err, doc) => {
           if (err) {
-            return cursor._endSession
-              ? cursor._endSession(() => handleCallback(cb, err))
-              : handleCallback(cb, err);
+            return handleCallback(cb, err);
           }
 
           if (doc == null) {
@@ -914,38 +912,18 @@ class Cursor extends CoreCursor {
     if (typeof options === 'function') (callback = options), (options = {});
     options = Object.assign({}, { skipKillCursors: false }, options);
 
-    this.s.state = CursorState.CLOSED;
-    if (!options.skipKillCursors) {
-      // Kill the cursor
-      this.kill();
-    }
-
-    const completeClose = () => {
-      // Emit the close event for the cursor
-      this.emit('close');
-
-      // Callback if provided
-      if (typeof callback === 'function') {
-        return handleCallback(callback, null, this);
-      }
-
-      // Return a Promise
-      return new this.s.promiseLibrary(resolve => {
-        resolve();
-      });
-    };
-
-    if (this.cursorState.session) {
-      if (typeof callback === 'function') {
-        return this._endSession(() => completeClose());
+    return maybePromise(this, callback, cb => {
+      this.s.state = CursorState.CLOSED;
+      if (!options.skipKillCursors) {
+        // Kill the cursor
+        this.kill();
       }
 
-      return new this.s.promiseLibrary(resolve => {
-        this._endSession(() => completeClose().then(resolve));
+      this._endSession(() => {
+        this.emit('close');
+        cb(null, this);
       });
-    }
-
-    return completeClose();
+    });
   }
 
   /**

package/lib/error.js

@@ -1,45 +1,38 @@
 'use strict';
 
 const MongoNetworkError = require('./core').MongoNetworkError;
-const mongoErrorContextSymbol = require('./core').mongoErrorContextSymbol;
 
-const GET_MORE_NON_RESUMABLE_CODES = new Set([
-  136, // CappedPositionLost
-  237, // CursorKilled
-  11601 // Interrupted
+// 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
 ]);
 
-// From spec@https://github.com/mongodb/specifications/blob/7a2e93d85935ee4b1046a8d2ad3514c657dc74fa/source/change-streams/change-streams.rst#resumable-error:
-//
-// An error is considered resumable if it meets any of the following criteria:
-// - any error encountered which is not a server error (e.g. a timeout error or network error)
-// - any server error response from a getMore command excluding those containing the error label
-//   NonRetryableChangeStreamError and those containing the following error codes:
-//   - Interrupted: 11601
-//   - CappedPositionLost: 136
-//   - CursorKilled: 237
-//
-// An error on an aggregate command is not a resumable error. Only errors on a getMore command may be considered resumable errors.
-
-function isGetMoreError(error) {
-  if (error[mongoErrorContextSymbol]) {
-    return error[mongoErrorContextSymbol].isGetMore;
-  }
-}
-
-function isResumableError(error) {
-  if (!isGetMoreError(error)) {
-    return false;
-  }
-
+function isResumableError(error, wireVersion) {
   if (error instanceof MongoNetworkError) {
     return true;
   }
 
-  return !(
-    GET_MORE_NON_RESUMABLE_CODES.has(error.code) ||
-    error.hasErrorLabel('NonRetryableChangeStreamError')
-  );
+  if (wireVersion >= 9) {
+    return error.hasErrorLabel('ResumableChangeStreamError');
+  }
+
+  return GET_MORE_RESUMABLE_CODES.has(error.code);
 }
 
-module.exports = { GET_MORE_NON_RESUMABLE_CODES, isResumableError };
+module.exports = { GET_MORE_RESUMABLE_CODES, isResumableError };

package/lib/operations/connect.js

@@ -290,6 +290,12 @@ function connect(mongoClient, url, options, callback) {
       delete _finalOptions.db_options.auth;
     }
 
+    // `journal` should be translated to `j` for the driver
+    if (_finalOptions.journal != null) {
+      _finalOptions.j = _finalOptions.journal;
+      _finalOptions.journal = undefined;
+    }
+
     // resolve tls options if needed
     resolveTLSOptions(_finalOptions);
 

package/lib/operations/cursor_ops.js

@@ -134,10 +134,9 @@ function toArray(cursor, callback) {
   const fetchDocs = () => {
     cursor._next((err, doc) => {
       if (err) {
-        return cursor._endSession
-          ? cursor._endSession(() => handleCallback(callback, err))
-          : handleCallback(callback, err);
+        return handleCallback(callback, err);
       }
+
       if (doc == null) {
         return cursor.close({ skipKillCursors: true }, () => handleCallback(callback, null, items));
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongodb",
-  "version": "3.5.7",
+  "version": "3.5.8",
   "description": "The official MongoDB driver for Node.js",
   "main": "index.js",
   "files": [
@@ -68,7 +68,7 @@
     "test": "npm run lint && mocha --recursive test/functional test/unit test/core",
     "test-nolint": "mocha --recursive test/functional test/unit test/core",
     "coverage": "istanbul cover mongodb-test-runner -- -t 60000 test/core test/unit test/functional",
-    "lint": "eslint lib test",
+    "lint": "eslint -v && eslint lib test",
     "format": "prettier --print-width 100 --tab-width 2 --single-quote --write 'test/**/*.js' 'lib/**/*.js'",
     "bench": "node test/benchmarks/driverBench/",
     "generate-evergreen": "node .evergreen/generate_evergreen_tasks.js",